Professional Documents
Culture Documents
2007/2008
Ministère de l’enseignement supérieur et de la recherche
scientifique
Institut National de formation en Informatique (I.N.I)
Oued-Smar, Alger
Thème
Conception et Réalisation d’un Système de Supervision
Informatique à base d’Agents Mobiles
PROMOTION : 2007/2008
INSTITUT NATIONAL D’INFORMATIQUE
BOUSSALEM Assam
ZERARA Younes
INEODEV Limited / INI
SEPTEMBRE 2008
Nous remercions ALLAH le tout puissant de nous avoir donné la force et le courage
pour réaliser ce travail.
Nos vifs remerciements, accompagnés de toute notre gratitude, vont tout d’abord à notre
promoteur Mr. Djamel-Eddine MENACER, et à notre Co-promoteur Mr. Younes HAFRI,
pour nous avoir proposé ce sujet, pour les conseils utiles qu’ils n’ont cessé de
nous prodiguer, les orientations et l’intérêt qu’ils nous ont montré
durant la progression de ce travail.
Nous tenons à remercier les membres du jury pour l’honneur qu’ils nous ont fait en
acceptant de juger ce travail.
Ce travail n’aurait sans doute pu voir le jour sans le soutien de nos parents, nos proches et
de nos amis, que nous les remercions affectueusement.
Que tous ceux, de près ou de loin, ont contribué, par leurs conseils, leurs encouragements
ou leur amitié, à l’aboutissement de ce travail, trouvent ici l’expression
de notre profonde reconnaissance.
IV
Dédicaces
Younes
A mon père mon professeur de toujours, et ma très chère mère
A tous ceux qui sont proches de mon cœur et dont je n’ai pas cité le nom.
Assam
Je dédie cet humble travail,
À mes proches amis et toute ma grande famille, pour leurs soutient et encouragements,
V
Résumé
Les systèmes multi-agents font de nos jours l’actualité dans le
domaine de l’intelligence artificielle ainsi que dans le développement
des applications distribuées autonomes. Ils touchent divers domaines
qui visent une automatisation des tâches de l’homme, entre autres,
les systèmes de supervision qui sont indispensables dans les systèmes
informatiques de l’entreprise.
VI
Sommaire
VII
2.1.2 IBM Tivoli Monitoring .............................................................................................. 14
2.2 Les offres du monde libre ..............................................................................................15
NAGIOS : ............................................................................................................................... 16
1 Fonctionnalités de Nagios ............................................................................................ 16
2 Architecture de Nagios .................................................................................................. 17
3 Principes de bases de Nagios ...................................................................................... 18
4 Mise en réseau de la supervision avec Nagios ............................................................ 19
3 Limite des systèmes actuels ................................................................................................ 20
4 Conclusion............................................................................................................................. 22
VIII
5 Les agents mobiles ...............................................................................................................40
5.1 Qu’est ce qu’un agent mobile ? ..................................................................................... 41
5.1.1 Définition .................................................................................................................. 41
5.1.2 Attributs d’un agent mobile.................................................................................... 41
5.1.3 Caractéristiques d’un agent mobile ....................................................................... 42
5.1.4 Types d’agents mobiles .......................................................................................... 43
5.1.5 Avantages des agents mobiles ............................................................................... 44
5.2 Paradigme d’agent mobile ............................................................................................ 45
5.2.1 Schéma d’organisation Client/Serveur ................................................................... 45
5.2.2 Autres schémas d’organisation avec mobilité ......................................................46
5.2.3 Fonctionnement des agents mobiles .................................................................... 48
6 Conclusion.............................................................................................................................49
IX
Chapitre 5 : Implémentation .................................................................................................. 67
1 Introduction .......................................................................................................................... 67
2 Environnement de développement .................................................................................... 67
2.1 Plateforme JADE pour le développement des SMA.....................................................68
2.2 Environnement Eclipse pour programmer en JAVA ....................................................69
2.3 Le package ‘’SNMP4J’’ pour les tests des services .....................................................69
3 Intégration de JADE et SNMP4J dans Eclipse ....................................................................69
4 Présentation de l’interface de MAMS (Multi Agent Monitoring System) .......................71
5 Mise en pratique ................................................................................................................... 72
6 Services supervisés .............................................................................................................. 73
7 Nœuds supervisés ................................................................................................................ 74
8 Conclusion............................................................................................................................. 75
Conclusion générale................................................................................................................ 76
X
Liste des figures
Introduction générale
1. Contexte de travail
Dans le domaine des entreprises modernes, l’adoption d’un système informatique
facilite énormément les processus d’administration (personnelle et matérielle) et de
productivité. Un tel outil aide à bien satisfaire les exigences croissantes non seulement des
administrateurs, mais aussi des utilisateurs, c’est pourquoi les développeurs conçoivent ce
système d’une telle façon que tous les besoins soient satisfaits à travers une bonne gestion
de toutes les branches de l’entreprise.
En effet, toutes les entreprises, de nos jours, sont équipées d’un réseau local au
minimum, et pour les plus importantes d’entre elles de réseaux longue distance (Wide Area
Network), leurs parcs informatiques englobent des centaines, voire des milliers de
terminaux engendrés par des serveurs de bases de données et des serveurs de
traitements.
2. Problématique
Actuellement, dans un environnement d’entreprise basé sur l’informatique, il est plus
important que jamais d’identifier et de résoudre les interruptions de service et les goulets
d’étranglement qui menacent les applications vitales, et ce avant tout impact sur la
productivité du système et la satisfaction de l’utilisateur.
De ce fait, ces entreprises ont suivi plusieurs démarches pour surveiller et assurer la
bonne gestion de leurs systèmes. Ces dernières peuvent nécessiter beaucoup de personnel
et d’argent s'il s'agit de gérer des systèmes éloignés à l’aide de systèmes d’exploitation
différents.
Plus important encore, avec tous les nouveaux équipements et les nouvelles
technologies apparues et qui évoluent chaque jour, les réseaux se complexifient et la tâche
de la surveillance devient de plus en plus difficile. Cette complexité permet l’accès à un
nouveau marché pour les constructeurs qui désormais se lancent dans le développement
et la vente de logiciels de supervision.
Mais bien que leur efficacité ait été prouvée, presque toutes les solutions de supervision
actuelles se limitent à effectuer des vérifications locales ou distantes sur les machines et
services du réseau, et d’en communiquer les résultats ou signaler des pannes éventuelles le
cas échéant. Dans ce dernier cas, le logiciel de supervision alerte l’administrateur qui doit
intervenir manuellement pour le bon fonctionnement du système. Cela rend les choses
plutôt pénibles et exige toujours la présence humaine et l’intervention manuelle, parfois
même tardive, ce qui devient à la limite coûteux et influe sur l’efficacité et la fiabilité du
système informatique de l’entreprise. En effet, un client de la S.A.R.L. INEODEV Limited
veut remédier à ce manque, puisqu’il dispose d’un moniteur de supervision Open-Source
(NAGIOS : leader dans le monde libre). Ce client veut améliorer la qualité de ses services
offerts en perfectionnant son monitoring system avec l’automatisation de certaines tâches.
D’un autre point de vue, les applications d’aujourd’hui deviennent de plus en plus
distribuées dans de multiples objets et fonctionnalités qui sont amenés à coopérer. La
décentralisation est donc la règle et une organisation coopérative entre modules logiciels
2
Introduction générale
est un besoin. En contrepartie, la taille, la complexité et l’évolutivité croissantes de ces
nouvelles applications informatiques font qu’une vision centralisée, rigide et passive
(contrôlée explicitement par le programmeur) atteint ses limites.
3. Objectifs
Devant ce constat et dans le cadre de ce mémoire, nous avons fixé l’objectif de
concevoir et de réaliser un système de monitoring informatique, qui pour le mettre en
œuvre, nous nous dirigeons naturellement vers une solution distribuée.
Plus précisément, nous suivrons l'approche d'agents mobiles qui est une nouvelle
architecture dédiée à la réalisation des systèmes distribués. Cette dernière modélise les
applications à travers un ensemble d'agents mobiles.
Notre travail consiste, alors, à implémenter une architecture à base d’agents adaptée à
la supervision informatique en assurant la détection des pannes dans un système
informatique donné. Puis, nous allons tenter de résoudre, s’il y a possibilité, les problèmes
qui apparaissent dans un environnement de réseau informatique pour offrir un meilleur
service. Pour réaliser ce travail, nous comptons atteindre les objectifs suivants :
4. Organisation du mémoire
Notre travail consiste à comprendre le fonctionnement de deux architectures
différentes, à savoir : les systèmes de supervision informatique et le paradigme d’agent.
I. La première partie est structurée en trois chapitres qui constituent notre état de
l’art :
1. La supervision informatique : présente une étude de la supervision informatique,
son rôle, ses principes et ses approches.
2. Les systèmes de monitoring existants : ce chapitre est consacré à la présentation
de quelques infrastructures de supervision qui feront l’objet de critiques.
3
Introduction générale
3. Le concept agent: aborde la notion de la technologie agent, des systèmes multi-
agents et des agents mobiles.
Finalement, nous terminons par une conclusion générale qui récapitule les principales
observations concernant l’évolution du travail et nous indiquons également comment les
travaux réalisés tout au long de ce mémoire pourraient être améliorés, en donnant des
perspectives.
A la fin de ce document, nous présenterons une annexe qui introduit des concepts
techniques utilisés pour la conception de notre système multi-agent, à savoir la plateforme
Jade.
4
Chapitre 1 La Supervision Informatique
1 Introduction
La gestion d'un parc de serveurs est un travail de chaque instant. Un bon
administrateur système doit savoir à tout moment l'état des différentes machines et des
différents services.
Cependant, l'administrateur ne peut pas se permettre de passer son temps devant un
tableau avec des voyants verts en attendant qu'un voyant passe au rouge pour agir, son
temps est occupé à d'autres tâches, donc il ne peut pas surveiller les statuts des machines
en permanence. L'examen quotidien des logs systèmes est un bon début, mais, si un
problème survient, on s'en rend compte seulement le lendemain, ce qui peut être trop
tard.
Pour simplifier leur travail, les administrateurs utilisent généralement ce qu’on appelle
un ‘’moniteur de supervision informatique’’, un tel moniteur permet d'avoir une vue globale
du fonctionnement de réseau ainsi que du niveau de performances des systèmes, et
d’alerter par différents moyens l’apparition d’une anomalie.
Dans ce chapitre, nous allons présenter les notions de base concernant la supervision
informatique.
5
Chapitre 1 La Supervision Informatique
D’un point de vue théorique, Eric D’HEM explique : « le Monitoring1 s’agit de répéter de
manière régulière un processus de test ou de surveillance d’une personne ou d’un bien. Le but
étant d’obtenir très rapidement et simplement une vision précise des événements ou
anomalies sur la période analysée » [Lien 3].
Entre outre, La supervision informatique consiste à indiquer et/ou commander l’état
d’un serveur, d’un équipement réseau ou d’un service software pour anticiper les
plantages ou diagnostiquer rapidement une panne [Lien 6].
1
Monitoring : mot en Anglais qui désigne la surveillance ou la supervision.
2
http://fr.wikipedia.org/wiki/Supervision
6
Chapitre 1 La Supervision Informatique
Cartographie : présente la vue d'ensemble de l'architecture informatique
surveillé.
Rapports d'activité (reporting): comme les tableaux de bord et les
histogrammes.
Il est à noter qu’à partir de ces fonctionnalités qui sont réalisées par des modules
spécifiques constituant le système de monitoring, trois niveaux d’informations se
dégagent [Lien 3]:
4 Rôle de la supervision
Deux phases sont importantes pour que les administrateurs soient capables atteindre
l’objectif voulu par la supervision, à savoir, surveiller le système et garantir sa disponibilité
même en cas d’anomalie [DOS, 06]:
7
Chapitre 1 La Supervision Informatique
- Tenter de prévenir en cas de problème (défaillances matérielles ou interruption des
services) et garantir une remontée d'information rapide ;
5 Aspects de la supervision
La supervision peut porter sur plusieurs aspects de l’informatique. Pour simplifier on
peut les classer dans trois catégories principales qui sont les suivantes [Lien 3]:
3. Le Contenu : Dans ce dernier cas, on analyse les informations retournées par les
éléments surveillés pour détecter, par exemple, la suppression d’un fichier sur un
serveur FTP, la modification d’une page Web ou encore la disparition d’un mot clef.
6 Protocole SNMP
Le principe de base de la supervision est d’avertir d’un problème le responsable d’une
ressource avant même que les utilisateurs ne s’en aperçoivent, ce responsable pourra ainsi
intervenir dans les plus brefs délais sur l’ordinateur ou le service en question. Ceci permet
d’être proactif pour un service informatique qui gère de nombreux serveurs sur lesquels
résident beaucoup de services.
8
Chapitre 1 La Supervision Informatique
Il existe plusieurs méthodes pour superviser un système informatique :
Analyser les fichiers ‘’log’’ ou ‘’journaux’’ : qui sont des fichiers regroupant l'ensemble
des événements survenus sur un service, une application, un serveur ou tout autre
système informatique.
Récupérer des résultats de commandes et de scripts locaux ou distants ;
Utiliser le protocole SNMP (Simple Network Management Protocol) : qui va être
expliqué ainsi dessous.
9
Chapitre 1 La Supervision Informatique
2. Les agents : c'est-à-dire une application de gestion de réseau résidant dans un
périphérique et chargé de transmettre les données locales de gestion du
périphérique au format SNMP ;
3. Les systèmes de management de réseau (network management systems notés
NMS), c'est-à-dire une console à travers laquelle les administrateurs peuvent
réaliser des tâches d'administration.
Voici ci-dessous un schéma qui présente les éléments de base du protocole SNMP:
3
UDP : en français protocole de datagramme utilisateur, c’est l’un des principaux protocoles de
télécommunication utilisés par Internet
10
Chapitre 1 La Supervision Informatique
mot de passe. Il y a un nom de communauté différent pour obtenir les droits en lecture et
pour obtenir les droits en écriture.
Dans bien des cas, les colossales lacunes de sécurité que comportent les versions 1 et
2 de SNMP limitent l'utilisation de SNMP à la lecture des informations car la communauté
circule sans chiffrement avec ces deux protocoles. Un grand nombre de logiciels libres et
propriétaires utilisent SNMP pour interroger régulièrement les équipements et produire
des graphes rendant compte de l'évolution des réseaux ou des systèmes informatiques
(MRTG, Cacti, Nagios, Zabbix...) [Lien 11].
7 Conclusion
La supervision informatique est indispensable pour une entreprise qui se respecte et
dont la défaillance d’un quelconque de ses services informatiques et l’indispensabilité de
son système d’information influent sur le rendement global de sa productivité.
Les systèmes de supervision feront l'objet de notre étude, Le chapitre suivant donnera
une vue détaillée des différentes infrastructures de monitoring existantes.
Pour pouvoir être efficace, la surveillance doit donc impérativement être effectuée
depuis différents points de contrôle sur une architecture distribuée, avec des techniques
permettant d'analyser et gérer en permanence les flux.
11
Chapitre 2 Les systèmes de monitoring existants
1 Introduction
Le marché de la supervision informatique déborde des logiciels de monitoring ; il en
existe une diversité, d’autres sont payants et d’autres font parti du monde libre ou on peut
même trouver des Open Source, Nous allons dans ce qui suit citer quelque uns et nous
détaillerons les plus connus et répandus dans le milieu des entreprises.
2 Le marché de la supervision
Le marché de la supervision peut être découpé en deux grandes sous-parties :
Les offres éditeurs : qui permettent de fournir des moniteurs de supervision
payants.
Les offres du monde libre : qui permettent d’avoir des moniteurs gratuits
(Open-source).
12
Chapitre 2 Les systèmes de monitoring existants
Ces outils, véritables frameworks de la supervision, possèdent tous leurs avantages et
inconvénients face à la concurrence. Et bien entendu, tous ont également le même défaut,
à savoir: leurs prix couteux !
Cette constatation faite, il est alors logique de voir de plus en plus de sociétés
aujourd'hui regarder du côté du logiciel libre, où les projets commencent depuis quelques
années à devenir de plus en plus professionnels et suivis.
Dans ce qui va suivre, nous présenterons deux leaders des logiciels payants de
supervision : HP OpenView et IBM Tivoli.
2.1.1 HP OpenView
HP OPEN VIEW est un outil de supervision reconnu sur le marché. Son principal
avantage est la centralisation des informations sur un seul poste. Il a pour rôle de gérer et
de surveiller entre autre les infrastructures et services réseaux. Ce logiciel est donc destiné
aux moyennes et grandes entreprises qui souhaitent avoir une vue global de leur réseau et
de son état [Lien 12].
1. Principe de fonctionnement
HPOV est un produit qui propose, aux personnes chargées de l’exploitation des
systèmes d’information, un outil favorisant :
une vue globale du système d'information ;
un contrôle homogène des différents composants du système informatique ;
une vision des incidents et leur impact.
La plate-forme HP OpenView est composée principalement de :
OVOW (OpenView Opération for Windows) : composé d’une base SQL SERVER;
Le logiciel est assorti d’un serveur HTTP Apache pour l’accès aux interfaces Web des
outils.
2. La console OVOW
La console OVOW permet à l'opérateur d'avoir une vision globale de son réseau
informatique. L’opérateur peut visualiser d’un seul coup d’œil la disponibilité globale d’un
service, la gravité d’une erreur, la raison principale de cette erreur ...
Les nœuds
Pour OVOW, chaque client est un « nœud ». Un nœud correspond donc à un élément
surveillé (un nœud peut être un serveur, un photocopieur …).
14
Chapitre 2 Les systèmes de monitoring existants
Aide à optimiser l’offre de services informatiques en intégrant des produits de
gestion et des processus informatiques pour stimuler les performances et respecter
les accords de niveau de service ;
Aide à optimiser le temps de réalisation en simplifiant l’installation et la surveillance,
avec également des fonctionnalités de gestion s’appuyant sur des technologies
pointer-cliquer [Lien 13].
4
Net Saint : c’est l’ancienne appellation du NAGIOS
15
Chapitre 2 Les systèmes de monitoring existants
ZENOOS représente une alternative à des plates-formes de supervisions comme Tivoli
ou OpenView, notamment pour les entreprises de taille moyenne.
Il assure des fonctions de découverte, d'inventaire, de supervision de la
disponibilité, de gestion de la performance, de gestion des évènements et des alertes
qui peuvent être envoyées par email. Le produit fédère et s'interface avec de
nombreux utilitaires de supervision et d'administration open source. Zenoss est
disponible en version GPL ou commerciale (avec support).
Le moniteur Nagios qu’utilise actuellement le client d’INEODEV Limited et que nous
allons le décrire, ainsi dessous, est considéré comme la solution la plus aboutie dans son
genre et la plus utilisée dans le monde du logiciel libre de supervision.
NAGIOS :
Nagios, le successeur de Netsaint, est un logiciel de monitoring et de supervision libre
sous licence GPL.
Il offre une solution de surveillance efficace dans un système informatique complexe. Il
permet de surveiller le bon fonctionnement des services d’une ou plusieurs machines dans
un réseau hétérogène. Il est écrit en C et fonctionne grâce à un ensemble de plugins (qui
eux peuvent être écrits dans n’importe quel langage).
Prévu à l'origine pour fonctionner sous Linux, Nagios devrait fonctionner également
sous les autres systèmes Unix.
Plusieurs améliorations ont été apportées à Nagios pour qu'il devienne un partenaire
simple à utiliser et remarquablement fiable et efficace.
1 Fonctionnalités de Nagios
Nagios offre à l'utilisateur plusieurs fonctionnalités, à savoir [Lien 14] :
Surveillance des services réseaux (SMTP, POP3, HTTP, NNTP, PING, etc.) ;
Surveillance des ressources des hôtes (charge processeur, utilisation des disques,
etc.) ;
Permettre aux utilisateurs de développer facilement leurs propres vérifications de
services grâce à son système de plugins ;
Paralléliser la vérification des services ;
Possibilité de définir la hiérarchie du réseau en utilisant des hôtes "parents", ce qui
permet la détection et la distinction entre les hôtes qui sont à l'arrêt et ceux qui sont
injoignables ;
Notifications des contacts quand un hôte ou un service a un problème et quand celui-
ci est résolu ;
16
Chapitre 2 Les systèmes de monitoring existants
Possibilité de définir des gestionnaires d'évènements qui s'exécutent pour des
évènements sur des hôtes ou des services, pour une résolution proactive des
problèmes ;
Rotation automatique des fichiers log ;
Support pour l'implémentation de la surveillance redondante des hôtes ;
Interface web optionnelle, pour voir l'état actuel du réseau, notification et historique
des problèmes, fichiers log, etc. ;
Une interface permettant l’intégration simple de plugins ;
De prévenir par email ou par toute autre méthode personnalisée en cas de problème ;
Déclencher des procédures personnalisées pour résoudre les problèmes ;
La consultation des différents événements et données collectés via une interface
web ;
Archivage automatique des données collectées ;
Dans la figure suivante, les fonctionnalités de Nagios se résument [OUD, 05]:
Cependant, pour pallier aux éventuelles lacunes du Nagios, des plugins peuvent être
ajoutés qui sont personnalisés selon les besoins d’utilisation, pour accomplir ou améliorer
d’autres services et tâches.
2 Architecture de Nagios
Nagios est un programme modulaire de telle sorte que son évolution puisse être facile,
il se compose principalement de trois parties [Lien 6]:
17
Chapitre 2 Les systèmes de monitoring existants
1. L’ordonnanceur : c’est le moteur de l’application qui s’occupe de
l’ordonnancement des tâches de supervision.
2. L’interface Web : qui permet d’avoir une vue d’ensemble du système
d’information et des possibles anomalies, Nagios s’appuie sur simple serveur
Web tel apache basé sur des CGI.
3. Les sondes : Les sondes de Nagios (Plugins ou Greffons) sont de petits scripts
ou programmes qui sont à la base des vérifications. Ces minis programmes que
l’on peut compléter selon nos besoins pour superviser chaque tache
Nagios peut aussi gérer ses données dans des bases de données (MySQL ou
PostgreSQL) ou bien dans des fichiers textes.
La figure 4 montre cette architecture [Lien 6]:
19
Chapitre 2 Les systèmes de monitoring existants
2. NSCA (Nagios Service Chek Acceptor) qui permet de son coté la remontée
d’information de façon passive vu du point de vue de Nagios, c’est ce qu’on
appelle la supervision passive.
L’ordonnancement des vérifications est assuré de façon locale à chaque
machine et surtout permet d’inverser le sens des connexions entre serveur
supervisé et serveur superviseur qui peut avoir un intérêt dans un réseau
sécurisé.
3. NSClient++ : qui est un greffon (plugin) lourd pour la supervision des serveurs
Windows NT/2K/XP.
4. Check_Snmp : pour la supervision basée sur SNMP à travers le réseau.
20
Chapitre 2 Les systèmes de monitoring existants
Cependant, parfois il arrive qu’un problème apparaisse sur un site distant, quand il
s’agit d’un système complexe (réseau MAN ou WAN par exemple), donc il faudrait s’y
déplacer pour le solutionner. Cela rend les choses plutôt pénibles et exigent toujours la
présence humaine et l’intervention manuelle, ce qui devient à la limite coûteux et influe sur
l’efficacité et la fiabilité du système.
Pour remédier à ce type de problèmes, nous nous proposons d’utiliser un logiciel qui
réunit à la fois le monitoring et l’intervention automatique et cela en intégrant la
technologie d’agent mobile5 dans un système de monitoring. En effet, une telle plate-
forme à agents mobiles peut apporter une aide substantielle à un administrateur, puisque
certaines tâches routinières (par exemple la défragmentation périodique d’un disque),
peuvent être directement effectuées par des agents mobiles.
Le schéma précédent peut alors se basculer vers le schéma suivant (Figure 7):
5
La technologie d’agent (particulièrement : l’agent mobile) sera être décrite dans le chapitre suivant.
21
Chapitre 2 Les systèmes de monitoring existants
La solution donc va effectuer le rôle d’un logiciel simple de monitoring en cas de bon
fonctionnement, mais en cas de panne, elle sera capable d’en assurer le diagnostic et la
résolution automatique.
4 Conclusion
Tous ces logiciels que nous avons décris ci-dessus sont considérés comme un
aboutissement et une réussite dans leur branche, cependant, on voit qu’ils ont tous leurs
propres inconvénients qui doivent être résolus.
Un bon moniteur de supervision doit englober tous les avantages de ces derniers et
aussi, se remédier à leurs lacunes et inconvénients afin de converger vers la perfection et
atteindre un niveau de supervision et de fiabilité optimum.
Pour cela, la mise en place d’un tel moniteur exige le bon choix de plate-forme de
développement qui conduit à la réalisation d’une architecture distribuée fiable et robuste.
22
Chapitre 3 Le concept Agent
1 Introduction
Durant la première génération des programmes informatiques, l'ordinateur était
chargé de réaliser des tâches prises en charge habituellement par un homme. Ce
remplacement progressif de l'homme par la machine s'est accompagné d’une
identification de la machine à l'humain ; un programme représentant l'expert sera capable
de résoudre le problème par lui-même.
Cette façon de concevoir les programmes comme des sortes de penseurs repliés sur
eux-mêmes a trouvé sa limite lorsqu'on a cherché à développer des applications plus
complexes, et habituellement, réalisées souvent par un groupe de personnes parfois
délocalisées. La machine devait alors être identifiée non uniquement à un humain mais à
une société organisée d'humains.
Les concepteurs des systèmes industriels complexes ont constaté que le savoir-faire,
les compétences et les connaissances diverses sont détenues par des individus différents
qui, au sein d'un groupe, communiquent, échangent leurs connaissances et collaborent à la
réalisation d'une tâche commune.
En effet, les méthodologies de réalisation d'applications informatiques se sont alors
concentrées sur les aspects organisationnels des logiciels et sur la représentation des
communications entre leurs différents composants.
Ainsi, on trouve parmi ces méthodologies qui convergent vers l’utilisation des entités
intelligentes coopérantes afin d’atteindre un objectif, la technologie des systèmes multi-
agents qui est une branche relativement récente de l’intelligence artificielle distribuée et
qui a enrichi cette dernière en suggérant l'usage de métaphores sociologiques et/ou
biologiques pour la conception de systèmes artificiels intelligents.
23
Chapitre 3 Le concept Agent
Cette terminologie rassemble les travaux qui portent sur l'étude et la conception
d'organisations d'agents (processus) autonomes, capables d'agir sur leur environnement
physique, et de communiquer ou d’interagir pour accomplir collectivement des tâches
spécifiques.
De ce fait, bien que la technologie des agents reste plutôt pénible à mettre en œuvre,
vu qu’elle est encore dans une phase de recherche et de développement quant aux
standards, plate formes, langages et protocoles, mais, elle retient de plus en plus
l’attention de la communauté informatique.
Dans ce chapitre, nous verrons les concepts fondamentaux de l’approche agent, nous
commencerons par introduire l’intelligence artificielle distribuée et l’évolution de cette
discipline jusqu’au systèmes multi-agents, nous mettrons ensuite l’accent sur l’évolution de
l’aspect individuel des agent vers l’aspect collectif, nous citerons également quelques
caractéristiques des systèmes multi-agents et nous finirons par introduire la notion des
agents mobiles qui est à son tour une nouvelle technologie qui émerge dans cette
discipline.
Mais, l’approche classique de l’intelligence artificielle a montré ses limites, puisque elle
s’appuie sur la centralisation d’expertises dans plusieurs domaines techniques et
disciplines pédagogiques au sein d’un seul système, et modélise le comportement
intelligent d’un seul agent (système).
24
Chapitre 3 Le concept Agent
2.2 Orientation vers l’intelligence artificielle distribuée
Pour résoudre des problèmes de l’intelligence artificielle centralisée, il est devenu
nécessaire de s’orienter vers une approche cartésienne (modulaire) et de distribuer
l’intelligence sur plusieurs entités (agents) décomposant ainsi un système complexe en
plusieurs sous systèmes de complexité inférieure. Ces derniers sont capables d’interagir
entre eux afin d’aboutir au but prédéfini du système original [ROU, 04].
De cette approche décentralisée utilisée dans le domaine de l’intelligence artificielle
est née l’Intelligence Artificielle Distribuée (IAD) qui est définie comme étant la branche de
l’intelligence artificielle classique qui s’intéresse à des comportements intelligents qui sont
le produit de l’activité coopérative de plusieurs agents. En d’autres termes l’IAD est le
passage du comportement individuel au comportement collectif pour combler les limites
de l’IA classique à résoudre des problèmes complexes à travers la conception des systèmes
intelligents par un ensemble d’entités (sous systèmes ou encore modules) plus simple où
chacune s’occupe d’une partie du problème tout en ayant au final une complexité globale
moindre [LAB, 93].
À la différence de l’intelligence artificielle classique qui modélise le comportement
intelligent d’un seul agent, l’intelligence artificielle distribuée se focalise sur le
comportement intelligent qui est produit par la coopération et la coordination entre
plusieurs agents. Et par conséquent, ces agents sont des membres d’un groupe travaillant
dans un but commun autour d’une activité complexe comme le contrôle de processus
industriels, la gestion de réseaux informatiques ou la coordination de rebots industriels.
L’IAD recouvre trois axes fondamentaux de recherche [LAB, 93]:
La résolution distribuée des problèmes (RDP) : Elle s'intéresse à la méthode de
division d’un problème donné sur un ensemble d'entités distribuées et
coopérantes et à la manière de partager la connaissance de ce problème et d'en
obtenir la solution.
L'Intelligence artificielle parallèle (IAP) : c’est l’étude de développement de
langages et d'algorithmes parallèles pour l’IAD. Elle vise l'amélioration des
performances des systèmes d'intelligence artificielle sans, toutefois, s'intéresser à
la nature du raisonnement ou au comportement intelligent d'un groupe d'agents.
Toutefois, il est vrai que le développement de langages concurrents et
d'architectures parallèles peut avoir un impact important sur les systèmes d’IAD.
Les systèmes multi-agents (SMA) : c’est la coopération entre un ensemble
d'agents (ou processus) dotés d'un comportement intelligent et la coordination
de leurs buts et leurs plans d'actions pour la résolution d'un problème souvent
complexe. C'est le thème auquel nous nous intéressons le plus dans ce document.
Dans ce qui va suivre, nous allons se pencher sur l’étude de ce dernier axe qui se base
principalement sur la notion d’agent.
25
Chapitre 3 Le concept Agent
3 Notion d’Agent
La technologie des agents offre une nouvelle méthode pour analyser, concevoir et
implémenter des applications sophistiquées car ils font partie du domaine IAD en
bénéficiant aussi d'autres disciplines comme les sciences cognitives, sociologie, et
psychologie sociale.
Le terme agent est associé à des concepts très différents. Un agent est simplement
une entité qui agit ou opère, donc on pourra trouver le terme agent à n’importe quelle
application informatique ayant des buts à atteindre. Il est aussi utilisé, depuis plusieurs
années, dans [SEK, 07]:
• le domaine de l’informatique distribuée pour distinguer entre les entités dédiées à
la résolution de tâches spécifiques telles que, agents utilisateurs, agents de
transfert de messages et agents de systèmes d’annuaire.
• le domaine de la gestion des réseaux, où l’on parle d’agents SNMP par exemple.
Pour clarifier ce concept dont ses origines sont diverses, plusieurs définitions ont été
proposées par différents auteurs.
En d’autres termes, J. FERBER le redéfinit comme suit : « Un agent est une entité
physique ou virtuelle :
26
Chapitre 3 Le concept Agent
8. qui peut éventuellement se reproduire,
9. dont le comportement tend à satisfaire ses objectifs, en tenant compte des ressources
et des compétences dont elle dispose, et en fonction de sa perception, de ses
représentations et des communications qu’elle reçoit. »
b. Selon M. WOOlDRIDGE, une définition plus récente et brève:
« Un agent est un système informatique capable d’agir de manière autonome et flexible dans
un environnement changeant» [WOO, 02].
Pour bien cerner cette notion, nous synthétisons qu’un agent informatique, ou plus
exactement une application agent, devra réaliser une certaine tâche au compte d’une
personne ou une application. Plus précisément une application agent sera orientée tâche,
c’est à dire qu’elle déploiera une activité (suite de fonctionnalités offertes par son
environnement), et sera caractérisée par un certain degré d’autonomie, d’interactivité et
de réactivité (ces propriétés seront développées plus loin).
Notons qu’on trouve cette notion d’agent dans divers domaines de l’informatique
[MEN, 04]:
Les systèmes multi-agents : provenant des domaines de la robotique et de
l’intelligence artificielle qui proposent de structurer une application en
différentes fonctions représentées chacune par un agent. Les différents
agents coopèrent pour la résolution des problèmes de l’application.
Les agents d’interface : provenant des domaines de l’interface homme
machine et de l’intelligence artificielle qui essayent de simplifier la vie de
l’utilisateur en automatisant des tâches réalisées couramment par
l’observation des comportements répétitifs ou en surveillant des ressources
comme le courrier électronique.
Les agents mobiles : provenant du domaine des réseaux dont l’objectif est la
réalisation de tâches réparties sur un ensemble de machines interconnectées
pour le compte d’un utilisateur ou d’une application.
27
Chapitre 3 Le concept Agent
humaine ou depuis un autre agent), il contrôle tout simplement ses actions ainsi que
son état interne ;
2- Sociabilité : est la capacité d’un agent de se trouver engagé dans des transactions
sociales comme la négociation ou la coopération pour résoudre un problème avec les
autres agents. Il sera alors capable d'interagir et de coopérer (par des langages de
communication) dans un environnement peuplé d’agents, afin de résoudre des
problèmes ou effectuer des tâches ;
3- Réactivité : est une propriété primordiale pour l’agent, c’est la capacité qu’a un agent
de modifier son comportement lorsque les conditions environnementales changent, il
pourra ainsi percevoir via des senseurs et agir via des effecteurs dans les temps requis
sur son environnement ;
5- Activité : un agent est toujours actif. Il s'exécute donc nécessairement dans un thread
ou un processus indépendant ;
7- Migration : l’agent peut se déplacer d’un système à un autre pour accéder à des
ressources distantes ou pour rencontrer d’autres agents (notion d’agent mobile).
8- Communication : c’est la possibilité d’échanges de messages entre agents. Un agent
peut invoquer une méthode d’un autre agent comme il peut lui envoyer des messages
s’il est autorisé à le faire. La communication inter-agents peut suivre trois schémas
différents [BAR, 03] :
Now-type messaging : c’est le type de messagerie le plus utilisé. C’est un type
synchrone. Il bloque l’exécution de l’émetteur du message jusqu’à ce que le
receveur aura complètement téléchargé le message et aura envoyé sa réponse.
Future-type messaging : c’est un type de messagerie asynchrone qui ne bloque pas
l’exécution. L’expéditeur retient une variable qui peut être utilisée pour obtenir le
résultat.
One-way-type messaging : c’est un type asynchrone qui ne bloque pas l’exécution
courante. L’expéditeur ne va pas retenir une variable pour ce message et le
récepteur ne va jamais répondre. Ce type est utile quand deux agents engagent une
conversation où l’agent expéditeur n’a pas besoin de la réponse de l’agent
récepteur.
28
Chapitre 3 Le concept Agent
3.3 L’Agent versus l’Objet
Les agents sont à la programmation orientée agent (POA) ce que sont les objets à la
programmation orientée objet (POO). En se basant sur les caractéristiques de l’agent, il est
remarquable qu’en développant des applications par l’approche orientée agent, le
problème est décomposé en modules (agents) ayant des interactions, une autonomie, et
un objectif spécifique à atteindre. Les concepts clés d’abstraction liés à un système orienté
agent sont : agent, interaction, organisation [SEK, 07].
La terminologie objet n’est pas adaptée aux systèmes agents même s’il existe une
similarité superficielle entre objet et agent, ceci s’explique à travers les points suivants
[COU, 07] :
les agents sont permanents actifs alors que les objets sont généralement passifs;
les agents sont autonomes et responsables de leurs actions alors que les objets ne
le sont pas toujours;
les comportements des agents dans les systèmes ne sont pas tous prévus ;
l’approche orientée-objet ne fournit pas un ensemble adéquat de concepts et de
mécanismes pour modéliser les systèmes complexes dans lesquels les rapports
évoluent dynamiquement;
« un agent est un objet actif ayant une autonomie et un objectif », c’est la définition
de certains chercheurs dans le domaine du paradigme agent.
29
Chapitre 3 Le concept Agent
La figure 8 présente le fonctionnement d’un agent réactif [Lien 1] :
Les défenseurs de cette approche partent du principe suivant : dans un système multi-
agent, il n’est pas nécessaire que les agents soient intelligents individuellement pour que le
système ait un comportement global intelligent car la coopération de ces agents de faible
granularité (à faible capacité d’action) mais beaucoup plus nombreux permet l'émergence
d'une intelligence. Les sociétés d'insectes comme les fourmis, les termites sont les
exemples les plus anciens d'agents réactifs. Les agents réactifs sont de plus bas niveau, et
ne disposent que d’un protocole et d’un langage de communication réduit.
L’absence de formalisme est l’inconvénient majeur de ce type d’agent, ce qui explique
la difficulté de la compréhension et la prédiction du comportement des agents, [WOO, 95].
30
Chapitre 3 Le concept Agent
La figure 9 montre les modules constituant un agent cognitif [Lien 2] :
La figure 10, nous montre un tableau comparatif entre les deux approches [ROU, 04]:
Couche cognitive
Couches Intermédiaires
Couche réactive
En effet, si l’agent perçoit des situations qu’il connait très bien, alors il s’agit d’un agent
réactif. Par contre, lorsque l’agent rencontre ou perçoit une situation familière et qu’il lui
suffit un simple raisonnement pour la résoudre, on parle d’un agent cognitif.
Dans certains cas, il peut toutefois s’avérer qu’un agent ne peut pas résoudre un
problème (situation non familière), l’agent aura donc besoin d’engager un processus de
coopération pour demander l’aide aux d’autres agents.
32
Chapitre 3 Le concept Agent
3.6 Utilisation des agents
Il y a évidemment plusieurs domaines d'utilisation pour les applications agents dû au
fait que les architectures basées sur les agents fournissent une manière bien particulière
afin d'aborder des problèmes rapidement. C'est pour cette raison que les agents soient
largement utilisés, actuellement et prochainement, dans les domaines suivants [MEN, 04]:
33
Chapitre 3 Le concept Agent
Ce type d’agents forme ce qu’on appelle des Systèmes Multi-Agents. Ces derniers se
basent sur le principe suivant : au lieu d’avoir un seul agent en charge de l’intégrité d’un
problème, on considère plusieurs agents qui ont chacun en charge qu’une partie de ce
problème. La solution au problème initial est alors obtenue au travers de l’ensemble des
comportements individuels et des interactions, c'est-à-dire par une résolution collective.
Par conséquent, les systèmes multi-agents constituent l’un des champs de recherche
les plus actifs dans le domaine de l’informatique et ses champs d’application ne cessent de
s’élargir et de s’approfondir [RIC, 01].
4.1.1 Définition
Un Système Multi-Agents (avec son acronyme SMA, et MAS pour « Multi-Agent
System» en anglais) est un ensemble d’agents situés dans un certain environnement et
interagissant selon une certaine organisation6, il est défini comme étant un système
distribué composé d’un ensemble d’agents.
Une simple représentation symbolique est montrée dans la figure 12 [SEK, 07] :
6
http://fr.wikipedia.org/wiki/Syst%C3%A8me_multi-agents
34
Chapitre 3 Le concept Agent
Voici ci-dessous quelques définitions standards d’un SMA :
a. Selon J. Ferber les SMA sont définis de la façon suivante [FER, 97]:
un ensemble d’objets O. Ces objets sont situés, c’est-à-dire que, pour tout objet, il est
possible, à un moment donné, d’associer une position dans E. Ces objets sont passifs,
c’est-à-dire qu’ils peuvent être perçus, créés, détruits et modifiés par les agents;
un ensemble A d’agents, qui sont des objets particuliers (A ⊆ O), lesquels représentent
les entités actives du système ;
un ensemble de relations R qui unissent des objets (et donc des agents) entre eux;
b. J. Ferber a les redéfinit comme suit [FER, 97]: « Les systèmes multi-agents ont des
applications dans le domaine de l’intelligence artificielle où ils permettent de réduire la
complexité de la résolution d’un problème en divisant le savoir nécessaire en sous-
ensembles, en associant un agent intelligent indépendant à chacun de ces agents, on
parle ainsi d’intelligence artificielle distribuée ».
c. Un Système Multi-Agent est défini comme étant : un système distribué composé d’un
ensemble d’agents. Contrairement aux systèmes d’IA, qui simulent dans une certaine
mesure les capacités du raisonnement humain, les SMA sont conçus et implantés
idéalement comme un ensemble d’agents interagissant, le plus souvent, selon des
modes de coopération, de concurrence ou de coexistence [CHA, 94].
En synthétisant à partir de ces définitions, un SMA peut être assimilé à une population
d’agents autonomes en interaction, où la coopération et la coordination deviennent plus
importantes que l’intelligence individuelle.
Nous pouvons tirer, alors, que le but d’un SMA est de faire fonctionner un ensemble
d’agents pour résoudre des problèmes, accomplir des tâches fonctionnelles et simuler des
systèmes existants.
35
Chapitre 3 Le concept Agent
Chaque agent possède des informations ou des capacités de résolution des
problèmes limitées : on dit qu’il a un point de vue partiel ;
un agent est capable de coordonner ses activités avec les autres agents pour accéder
à des ressources et à des services partagés dont il a besoin (pour réaliser ses buts).
36
Chapitre 3 Le concept Agent
Les méthodologies orientées agents sont devenues une priorité pour le
développement de systèmes complexes. Il s’agit avant tout de tirer parti des modèles,
méthodes et outils déjà proposés pour faciliter la construction de systèmes multi-agents.
La plupart des méthodologies pour les systèmes multi-agents sont des extensions des
méthodologies orientées-objets et restent ainsi incomplètes. De plus, peu d’efforts ont été
faits pour la normalisation des méthodologies orientées agents et les plates formes
d’exécution.
Dans ce qui va suivre, nous allons détailler l’une des méthodologies les plus utilisées :
La méthodologie Voyelles
La méthodologie Voyelles (AEIO) se décompose en 4 parties [DEM, 95] :
Agents : qui concernent les modèles (ou les architectures) utilisés pour la partie active
de l’agent, depuis un simple automate à un complexe système à base de
connaissances.
Environnements : qui sont les milieux dans lesquels sont plongés les agents. Ils sont
généralement spatiaux dans la plupart des applications multi-agents.
Interactions : qui concernent les infrastructures, les langages et les protocoles
d’interactions entre agents, depuis de simples interactions physiques à des
interactions langagières par actes de langage.
Organisation : qui structure les agents en groupes, hiérarchies ou en relations.
37
Chapitre 3 Le concept Agent
c. Phase de programmation : (ou d’implémentation) consiste en l’instanciation des
modèles, en utilisant des plates-formes et des langages choisis. Le résultat, le
système implémenté, peut alors être exécuté, évalué (test et validation) et repensé
en cas d’inadéquation avec les besoins exprimés par le type de problème et le
domaine d’application.
38
Chapitre 3 Le concept Agent
les connaissances insuffisantes peuvent être complétées suivant la résolution ;
ils permettent de résoudre des problèmes de taille et de complexité telle qu’il n’est pas
réaliste d’essayer de les résoudre avec un seul agent ;
la modularité : la complexité d’un système d’IA croit avec la taille de sa base de
connaissances. Partitionner ce système en N agents réduit sa complexité par un
facteur parfois plus grand que N, et la configuration résultante se trouve plus facile à
développer, à tester et à maintenir ;
Aussi, la technologie agent a trouvé sa place dans les systèmes dynamiques, où l’action
autonome, la flexibilité et l’intelligence sont requises quand les quantités de données à
traiter dépassent l’envergure de traitement sur une seule machine. Cette approche
constitue un bon moyen de résolution et d’appréhension des problèmes [WOO, 95]. Cela,
explique l’utilisation actuelle des systèmes multi-agents dans divers domaines, dont nous
avons cité quelques uns brièvement :
- le web sémantique et la gestion documentaire sur le web ;
- les réseaux tels que Peer to Peer (P2P) ;
- les systèmes distribués concurrents et les bases de données reparties ;
- le commerce électronique sur le net et la gestion des processus d’affaires ;
- les systèmes d’information coopératifs ;
- les télécommunications ;
- les interfaces humain machine (HCI pour humain machine interface)…etc.
39
Chapitre 3 Le concept Agent
40
Chapitre 3 Le concept Agent
Sur le plan commercial, ce nouveau concept n’a pas encore suscité de grandes
applications. Mais, la communauté informatique pense que les agents mobiles vont jouer
un rôle important dans l’informatique de demain, notamment Internet.
5.1.1 Définition
Nous avons jugé utile de citer quelques définitions pour mieux comprendre son
fonctionnement :
Un agent mobile est un programme avec un but précis, capable de suspendre son
exécution sur une plate-forme pour se déplacer vers une autre plate-forme où il
reprend son exécution [LAR, 03].
Un agent mobile est un agent logiciel qui peut se déplacer d’un site physique à un autre
en cours d’exécution pour se rapprocher de données ou de ressources. Non seulement,
il se déplace avec son code et ses données propres, mais aussi avec son état
d’exécution [MED, 07].
Un agent mobile peut se déplacer à travers un réseau hétérogène sous son propre
contrôle, migrant d’un site à un autre, c'est-à-dire que l’agent décide lui-même de
manière autonome de ses mouvements. Durant sa migration, l’agent mobile interagit
avec d’autres agents ou d’autres ressources (bases de données…), et généralement, il
revient sur son site initial une fois sa tâche est accomplie [GAR, 00].
42
Chapitre 3 Le concept Agent
mécanismes de récupération pour relancer l’agent à nouveau, une certaine
redondance (copies par exemple) est nécessaire.
5. La sécurité : il faut considérer avec précaution l’aspect de la sécurité des sites visités
par l’agent mobile d’une part et la sécurité des agents mobiles durant leurs exécutions
d’autre part.
En effet, le site d’accueil d’un agent doit se protéger contre la sur-utilisation des
ressources et les actions malveillantes (intentionnelles ou non) des agents accueillis.
Par exemple, des limitations sur la consommation des ressources (temps CPU, taille
mémoire) peuvent également être fixées.
En revanche, l’agent doit avoir l’assurance que ni son code ni ses données ne seront
modifiés par le système hôte. Ce problème est plus complexe que le précédent,
puisque tout ce qui est accessible par l’agent l’est aussi au système d’exploitation dans
lequel il s’exécute.
5. Adaptation dynamique :
Les agents mobiles, étant des agents, sont naturellement adaptatifs, c’est à dire
qu’ils perçoivent leur environnement d’exécution et réagissent aux changements.
En particulier dans un système multi-agents, les agents mobiles maintiennent une
configuration optimale pour résoudre un problème de manière coopérative.
6. Hétérogénéité naturelle :
Généralement, un agent mobile est Independent du matériel et des couches de
transport du réseau. Il dépend seulement de son environnement d’exécution. Les
agents mobiles conviennent bien aux réseaux hétérogènes.
44
Chapitre 3 Le concept Agent
7. Robustesse et tolérances aux pannes :
Grâce à leur capacité d’adaptation aux situations (surtout défavorables). Les
agents mobiles permettent de construire des applications distribuées robustes et
tolérantes aux pannes. En particulier, lorsque un hôte va être arrêté, tous les
agents s’exécutant sur cette machine seront notifiés et peuvent migrer sur un
autre site ou ils pourront continuer leur exécution.
Serveur
Clients
46
Chapitre 3 Le concept Agent
L’unité d’exécution et les ressources sont fixes, seul le savoir-faire (le code) est mobile.
L’appliquette ou applet Java qui est l’exemple le plus populaire : un programme est
chargé à partir d’une page Web pour être exécutée sur le site client, généralement, au sein
du navigateur Web.
47
Chapitre 3 Le concept Agent
5.1.2.3 Agents mobiles
Comme nous avons déjà montré, les agents mobiles sont des processus (code et unité
d’exécution) qui peuvent se déplacer, dans un réseau, d’eux-mêmes d’un site à un autre
pour interagir localement avec des ressources d’autres sites.
Dans ce schéma, le savoir-faire appartient au client. Nous pouvons dire que le schéma
d’évaluation distante est un cas particulier du schéma à agents mobiles.
Ce schéma s’explique ainsi, dans la figure 20 :
L’approche d’agents mobiles est plus générale : en plus du code, l’unité d’exécution
associée est mobile. De plus, les agents mobiles peuvent transporter des données
paramètres. Après l’exécution, l’agent peut, éventuellement, retourner au site initial.
48
Chapitre 3 Le concept Agent
La figure suivante (Figure 21) présente le paradigme d’agent mobile :
Les agents mobiles se déplacent d’une machine à l’autre. Pour migrer, un agent
transfère son code et ses données sur le nouveau site puis continue son exécution sur ce
site là. A l’issue de la migration, le processus de la machine initiale est détruit par une
commande du nouveau processus.
L’intérêt de ces agents concerne les recherches dans beaucoup de données sur des
sites éloignés. Ces agents peuvent servir à nous assister dans nos taches d’administrations
quotidiennes, ils filtrent par exemples des e-mails, partent à la recherche de virus,
détectent les intrusions dans les réseaux…Etc. En Bref, ils effectuent les opérations
d’administration de base sans solliciter d’interventions humaines. Ils peuvent
communiquer entre eux, analyser l’information qu’ils recueillent et avertir le cas échéant
l’administrateur du réseau. Par ailleurs ils permettent d’éviter d’avoir une station
d’administration centralisée et statique, car au contraire, ils peuvent être interrogés et
lancés à distance de n’importe où. Toutes ces facettes des agents mobiles permettent aux
administrateurs du système de rentrer pleinement dans l’aire de la mobilité.
6 Conclusion
49
Chapitre 3 Le concept Agent
Dans ce chapitre, nous avons présenté une vue détaillée sur une approche qui est
actuellement un champ de recherche très actif, l’approche « Agents ». Cette discipline de
l'intelligence artificielle qui s’intéresse, tout d’abord, aux notions d’agents et de Systèmes
Multi-Agents.
Nous avons détaillé par la suite les différentes questions relevées par la problématique
de ces systèmes, nous avons également bien détaillé la mobilité qui est considérée comme
le futur des systèmes multi-agents.
A travers cette étude, il nous est apparu que la robustesse de ce type de systèmes
repose sur la modularité de ses composants, la richesse des interactions et l'efficacité de
communication entre agents. Cette approche est donc très adaptée à la conception de
systèmes où plusieurs éléments indépendants doivent coopérer et accéder à des sources
hétérogènes et distribuées soit sur un réseau local (Intranet) soit sur Internet qui est
devenue une partie intégrante de la vie quotidienne des agents.
L’IAD et les SMA sont des thèmes de recherche en cours d’exploitation, ils font
intervenir plusieurs domaines de recherche tels que les systèmes répartis, la biologie, l’IA
et la psychologie cognitive.
Les principales conclusions que nous pouvons tirer de cette modeste recherche sont
les suivantes:
- L’IAD s’adapte mieux à la réalité des systèmes complexes que l’IA classique. Elle
enrichit le processus de résolution de problèmes en le partageant entre
plusieurs agents.
- L’interaction de plusieurs expertises incomplètes ou peu fiables à travers les
SMA peut mener à une expertise plus sure et plus robuste.
- La puissance du nouveau paradigme d’agent mobile le rend une méthodologie
prometteuse pour le développement des nouvelles applications distribuées.
50
Chapitre 4 La Conception
Chapitre 4 : Conception
1 Introduction
Dans ce chapitre, nous présenterons la conception de notre système basé sur un
modèle à d’agents mobiles. Nous avons pu voir dans le chapitre précédent que les
approches de détection se diversifies, et la détection porte sur plusieurs aspects, et donc,
pour pouvoir choisir une approche et trouver un compromis, nous allons proposer
plusieurs scenarios envisageables que nous allons critiquer pour bien se décider.
Nous insisterons aussi sur la solution libre NAGIOS qu’on pourrait utiliser pour la
détection et le protocole SNMP qui est l’approche la plus courante dans le domaine de
supervision.
Nous allons essayer de concevoir un prototype d’un système multi-agents ouvert, dans
le sens ou il sera extensible, par l’ajout éventuel d’autres agents, et modules de détection,
de récolte d’informations ou de réaction.
Ce chapitre sera organisé comme suit ; nous allons donner en premier une
présentation générale du système, nous donnerons par la suite une description des
différentes tâches et méthodes à implémenter dans les agents avec argumentation de nos
choix, en suite nous détaillerons l’architecture interne de chaque agent, et enfin, pour
terminer une présentation du fonctionnement du système sera donnée.
2 Fonctions principales
Comme nous l’avons déjà présenté, l’objectif principal de notre application est de créer
un système de monitoring informatique, notre travail s’agira, alors, d’une implémentation
d’une architecture à base d’agents mobiles adaptée à la supervision informatique en
assurant la détection des pannes dans un système informatique donné, puis, nous allons
tenter de résoudre si possible les problèmes qui apparaissent dans un environnement de
51
Chapitre 4 La Conception
réseau informatique pour offrir un meilleur service. En d’autres termes, nous concevons
notre solution comme un outil basé sur une approche de supervision pilotée par une
nouvelle technologie ; la technologie agent mobile.
Cet outil aura pour fonctions principales de :
1. Effectuer une série de tests système dans des sites donnés.
2. Visualiser ces résultats à travers une interface utilisateur.
3. Tenter si possible de réparer certaines anomalies ou signaler d’éventuels
problèmes persistants à l’utilisateur.
La figure suivante (Figure 22) illustre les différentes étapes de ce cas de figure.
52
Chapitre 4 La Conception
a) Le nœud de supervision lance des agents mobiles vers toutes les machines supervisées ;
ces agents disposent de base des connaissances dynamique et extensible.
b) L’agent mobile s’exécute dans la machine cible, cette exécution consiste à faire des
tests locaux c.à.d. des commandes système, s’il y a des problèmes l’agent réagit et tente
de régler les anomalies. Le cas échéant, il signale le problème au niveau du nœud central.
d) Après analyse du rapport des résultats envoyé, si l’utilisateur n’est pas satisfait, il peut
mettre à jour la base des connaissances des agents à travers une intervention manuelle ou
par la modification d’un moteur d’inférence.
La figure suivante (Figure 23) illustre les différentes étapes de ce cas de figure.
53
Chapitre 4 La Conception
Le serveur lance des agents d’analyse vers toutes les machines clientes.
a) Exécution des agents : Commandes de test systèmes, diagnostique des erreurs et
des pannes éventuelles.
b) L’envoie d’un rapport au serveur sera après la récolte des résultats des tests au
niveau des nœuds distants.
c) Si après analyse de rapport, il n’y a aucun problème, le système continu son travail
en recevant les rapports des agents mobiles qui testent les hôtes et les services à des
intervalles de temps bien définis, sinon le système renvoie un autre agent dédié pour
résoudre les problèmes survenus.
e) Ajout des règles supplémentaires par l’utilisateur en cas de non satisfaction et mise
à jour de la base des connaissances des agents de réparation.
54
Chapitre 4 La Conception
Avantages:
• Coté de détection assuré et fiable.
• Archivage des résultats des tests.
Inconvénients :
• Difficulté d’implémentation ; besoin de comprendre le code source de NAGIOS
fait avec le langage de programmation C et le langage de Script Perl.
La figure suivante (Figure 24) illustre les différentes étapes de ce cas de figure.
a) L’application envoie un agent qui a pour tâche la consultation des tables de la base
de données de Nagios afin de pouvoir récupérer les informations concernant les
états des machines et des services.
b) Retour de l’agent envoyé avec un rapport sur l’état actuel de chaque service.
c) Migration d’un agent dédié qui exécute des commandes système afin de résoudre
la panne ou récupérer la fonction d’un service après détermination d’erreur.
4 Conception
Lors de la rencontre d’un problème complexe, le mieux à faire est d’opter pour
l’approche de conception cartésienne et moduler le système le plus possible afin de
dégager les différents sous systèmes et leurs fonctions respectives.
Commençons tous d’abord par présenter la méthodologie de conception de notre
Système.
Agents :
Nous allons classer les agents et partager les tâches entre ces derniers, par
conséquent, nous allons avoir trois classes d’agents. La première classe, contient les
agents dont le rôle est la récolte des données, la deuxième classe d’agents effectue
l’analyse des données issues de la première classe afin de détecter les anomalies, et la
troisième classe contient les agents qui agissent en fonction des données.
• Agent de gestion : Utilisé pour la coordination et le pilotage de la supervision.
• Agents d’analyse : Utilisés pour la collecte d’informations utiles sur le réseau.
• Agent de réaction : Utilisé pour agir directement sur l’environnement.
56
Chapitre 4 La Conception
Environnement :
L’environnement contient les objets et l’ensemble des agents modélisés. Les agents
sont capables d’agir sur cet environnement à partir des entrées qu’ils reçoivent de ce
même environnement. Il est constitué par ce qui est fixe durant son activation.
L’environnement de notre SMA comporte l’ensemble de machines à superviser.
Interactions :
Les interactions sont primordiales dans ce système puisque à l’origine tout est basé sur
la coopération des agents identifiés précédemment.
Chaque opération est modélisée sous forme de suites de messages pour lesquels nous
présentons toutes les interactions possibles entre les différentes entités. Il existe deux
types d’interactions :
Organisation :
Une structure organisationnelle est définie par :
- un ensemble de classes d’agents caractérisées par les rôles affectés aux agents.
- un ensemble des relations abstraites existant entre ces rôles.
Ces deux points seront détaillés un peu plus loin dans ce chapitre.
Utilisateur :
Le seul utilisateur réel du système et l’administrateur du réseau et qui s’occupe de la
supervision. Cependant sa présence n’est pas obligatoire puisque la résolution des
défaillances éventuelles est pilotée et gérée entièrement par le moniteur de supervision
qui est essentiellement prévu pour un fonctionnement autonome.
57
Chapitre 4 La Conception
4.2 Phase 2 : Conception
4.2.1 Schéma général du système
Le schéma général de notre application peut être résumé comme suit ;
Agents de réaction : Ces agents quand à eux sont instanciés par l’agent de gestion
en but de réagir à un événement donné, ils intègrent des méthodes SNMP pour
gérer directement des services systèmes. Les agents de rection sont des agents
statiques ; c’est à dire qui s’exécutent une seule fois, ils s’autodétruisent dès que
leur tache ait été accomplie.
59
Chapitre 4 La Conception
La stratégie de supervision est basée sur une suite logique d’événements :
1. Au début un agent de gestion est créé dans le site de supervision pour gérer la
totalité de du processus.
2. Ensuite, on instancie pour chaque site distant un agent d’analyse qui va y résider
pour alléger le trafic dans le réseau.
4. L’agent de gestion analyse ces rapports et dans le cas d’une anomalie, il instancie un
agent de réaction dédié qu’il envoie directement au site en question pour résoudre
le problème. L’administrateur, quand à lui, est alerté de chaque étape durant
l’opération.
60
Chapitre 4 La Conception
4.3.3 Entités et modules du système :
Le schéma suivant résume les principales entités et composantes de notre système de
supervision :
L’administrateur interagit directement avec une interface utilisateur qui traduit les
résultats des données de test sous une forme simple et intuitive, et à travers laquelle on a
une vision globale du fonctionnement des différents services des réseaux supervisés.
Les agents du système quand à eux collaborent pour accomplir la tache de supervision,
les agents de test et de réaction sont ceux interagissent avec les nœuds du réseau, l’agent
de gestion est chargé de la synchronisation et la coordination de l’opération globale.
Les modules de test de connectivité sont utilisés dans le but de vérifier à chaque
moment la disponibilité des nœuds du système et avertir l’utilisateur dans le cas d’un
problème de connexion.
61
Chapitre 4 La Conception
4.3.4 Description des agents du système
La partie suivante est consacrée à la description des agents présentés précédemment
et à l’organisation et échange de données entre agents.
Agent de gestion
Le schéma suivant illustre mieux l’architecture interne de cet agent (Figure 28):
62
Chapitre 4 La Conception
Agent d’analyse
Agent de réaction
L’agent de réaction comprend principalement des modules SNMP pour manipuler des
services systèmes, il peut également faire appel direct à des fonctions système, les
modules de communication sont juste utilisés pour envoyer les rapports d’exécution de ce
dernier à l’agent de gestion et le passage des paramètres nécessaires (Adresse du nœud
présentant un problème et liste des services défaillants).
63
Chapitre 4 La Conception
Voici ci-dessous son architecture illustrée dans la figure 30 :
64
Chapitre 4 La Conception
Les différents messages échangés sont :
• Des requêtes envoyées par l’agent de gestion aux agents d’analyse (1) et de
réaction (2).
• Des rapports envoyés par les agents d’analyse et de réaction à l’agent de gestion
(3) et (4).
65
Chapitre 4 La Conception
5 Conclusion
Nous avons présenté dans ce chapitre la conception de notre système de supervision
basé sur un système multi agent utilisant l’approche SNMP implantée dans des agents
mobiles. Nous résumons les caractéristiques de notre prototype dans les points suivants :
- Architecture : Système multi-agent.
- Détection : Approche SNMP.
- Déploiement : Réseau.
- Comportement après rencontre d’anomalie : Actif (Tentative de résolution).
- Fréquence d’utilisation : Continue.
66
Chapitre 5 L’implémentation
Chapitre 5 : Implémentation
1 Introduction
Ce chapitre sera consacré à la l’implémentation et mise en pratique de notre système
de supervision. Nous commencerons par décrire les outils de développement utilisés, après
quoi nous présenterons l’interface utilisateur de notre système.
2 Environnement de développement
Dans la figure suivante, nous illustrons nos choix en termes d’environnement de
développement (Figure 32):
Le choix des outils de développement joue un rôle très important et décisif dans le
développent des applications. Plusieurs critères devront être définis et respectés. Parmi
ces critères on site :
67
Chapitre 5 L’implémentation
- Le temps de développement : nous devrons utiliser les outils qui minimisent le
temps de développement, et facilitent l’implémentation et la maintenance de
l’application.
- La stabilité : les outils utilisés devront être les plus stables possibles pour faciliter le
débogage lors du développement.
- La portabilité : les outils devront nous permettre de réaliser des applications
compatibles avec un grand nombre de plateformes matérielles et logicielles.
- Simplicité : facilité d’utilisation et disponibilité de la documentation.
- Les licences : notre préférence va aux outils libres de droits qui n’imposent pas de
restriction sur le développement et la diffusion de l’application.
Nous allons présenter dans ce qui suit les outils utilisés et les raisons du choix de
chaque outil.
Nous avons choisis JADE (Java Agent DEveloppement framework) pour les raisons
suivantes:
- Facilité d’installation.
- Documentation détaillée.
- Utilise un langage puissant et stable (JAVA).
- Intégration avec d’autres outils de développement (Intégration dans Eclipse via les
plugins EJIP et EJADE).
68
Chapitre 5 L’implémentation
- Licence libre (LGPL : (pour GNU Lesser General Public License) ; c’est une licence
utilisée par certains logiciels libres.).
La figure suivante (Figure 34) montre l’explorateur de package après intégration des
JARs.
Le JADE RMA est une console de la plateforme JADE, c’est un genre d’explorateur ou
on peut voir les conteneurs les agents actifs du système, le Main-Container est le
conteneur principal lancé dans la machine du serveur de supervision, les autres tels au
Container- 1 dans l’exemple suivant est le conteneur lancé à partir d’une autre machine et
relié au conteneur principal.
70
Chapitre 5 L’implémentation
La figure suivante présente l’interface utilisateur du JADE RMA (Figure 35).
71
Chapitre 5 L’implémentation
5 Mise en pratique
La supervision ne peut démarrer qu’après le lancement de la plate forme JADE dans
tout les nœuds du réseau, après quoi les différents agents pourront êtres exécutes et
migrés vers les différentes machines, JADE utilise un mécanisme souple pour le lancement
de la plate forme sur des machines distantes, c’est la notion de conteneurs qui existent en
deux types ; conteneurs principaux qui doivent être lancés dans des machines offrant
généralement des services comme dans notre serveur de supervision, et conteneurs
simples qui doivent être reliés au conteneurs principaux pour étendre la plateforme. Cette
notion est bien détaillée dans l’annexe.
La figure suivante montre l’application exécutée sur les machines qui vont être
supervisées, sont rôle est principalement de lancer la plate forme JADE et Le démarrage du
client SNMP sur la machine en question, pour le champ ou l’adresse doit être entrée, il
s’agit de l’adresse IP du serveur de supervision ou se trouve le conteneur principal avec
lequel sera relié le conteneur lancé par l’application cliente (Figure 37).
72
Chapitre 5 L’implémentation
6 Services supervisés
La supervision de notre application porte sur l’aspect fiabilité et disponibilité des
services systèmes. Le but de notre étude étant la recherche, nous avons donc cherché à
prouver la justesse de notre théorie et nous n’avons supervisé qu’un nombre restreint de
services système. On a choisi les services les plus connus de la communauté des
utilisateurs, à savoir ;
1. Le HyperText Transfer Protocol, plus connu sous l'abréviation HTTP.
2. Le service DHCP pour : Dynamic Host Configuration Protocol.
3. Le service d’accès au web à travers le réseau : WebClient.
4. Et le service connu Terminal Network ou TelNet.
Des voyants sont utilisés pour signaler l’état des services dans les tableaux de bord, à
savoir :
• Voyant vert : Service en marche
• Voyant rouge : Service interrompu
• Voyant bleu : Service ignoré
• Voyant orange : Etat du service inconnu
73
Chapitre 5 L’implémentation
7 Nœuds supervisés
Les nœuds supervisés sont enregistrés dans une liste dynamique, on peut avoir leurs
adresses IP ou les supprimer afin d’ignorer complètement leur comportement dans le
serveur de supervision. Dans leurs tableaux de bord respectifs, un voyant représenté par
un PC montre à tout instant si le nœud est toujours joignable (Voyant en couleurs) ou s’il
est déconnecté du serveur de supervision (Voyant en noir et blanc).
74
Chapitre 5 L’implémentation
La figure 39 montre la boite de dialogue des nœuds supervisés.
8 Conclusion
Dans ce chapitre, nous avons présenté les différents aspects liés à l’implémentation de
notre système. Cette partie nous a permis de toucher un peu au coté pratique et nous a
émergé dans les nouvelles technologies telles que les SMA et la supervision informatique,
ce qui nous a permis de comprendre le fonctionnement de ces technologies.
75
Conclusion et Perspectives
Conclusion générale
Nous avons tenté dans ce modeste travail de relier deux domaines très vastes de
l’informatique actuelle. D’un coté la supervision informatique et d’un autre l’intelligence
artificielle avec les systèmes multi-agents.
- Rajouter d’autres services pour enrichir et compléter les modules de supervision afin
d’être plus fiables et plus complets.
- L’archivage les données récoltées par les agents d’analyse pour des statistiques et
des traitements futures.
- Etendre les modules de détection et de réactions afin de superviser des machines des
réseaux hétérogènes.
- Elaborer d’autres versions pour autres systèmes d’exploitation comme Linux et
Solaris.
- L’utilisation d’agent mobile comme plugin pour NAGIOS serait aussi très intéressante.
« Il n’est pas tant important de tout savoir que de connaître la valeur exacte de chaque chose,
d’apprécier ce que nous apprenons, et de faire avec ce que nous savons. »
Hannah More
76
Bibliographie
Bibliographie et Web-graphie :
[BAR, 03] F.A. M. BARIKA, « Vers un IDS Intelligent à base d’Agents Mobiles »,
Université de Tunis, 2003
[DIE, 90] R. DIENG, « Relation Linking Cooperating Agents ». The 2nd European
Workshop MAAMA’90, page 185-202, Saint-Quentin in Yvelines-France
, Aout 1990.
[DOS, 06] T. DOSTES, « Mise en œuvre d’un portail de supervision des systèmes et
réseaux », Formation Nagios, Mars 2006.
77
Bibliographie
and Morgan Kaufmann: San Mateo, CA - 1989
78
Bibliographie
79
Web-graphie
[Lien 1] « Modèle Agent-Cellule, un Agent réactif »,
<http://www.limsi.fr/~jps/enseignement/examsma/2005/3.simulation_1/carriere.ht
ml>
80
Annexe : La plate-forme JADE
Nous allons décrire dans cette partie la plate-forme JADE et ses principales
caractéristiques.
1.1 - Introduction
JADE (Java Agent DEvelopment Framework) est une marque déposée, enregistrée par
CSELT (Centro Studi E Laboratori Telecomunicazioni)8, résulte principalement d'une
activité de recherche.
JADE est une plate-forme multi-agents crée par Bellifemine, Poggy et Rimassa en 1999,
elle permet le développement et l’exécution de systèmes multi-agents conformes aux
normes FIPA9 1997. La plate-forme est implémentée en Java et fourni deux composantes
de base : Une plate-forme agents compatible FIPA et un paquet logiciel pour le
développement des agents Java inclut
7
Application Programming Interface.
8
Groupe de recherche de Gruppo Telecom, Italie.
9
Foundation for Intelligent Physical Agents (organisation à but non lucratif produisant des normes pour l’interopérabilité
des agents hétérogènes de logiciels), son site principale : www.fipa.org
81
Annexe : La plate-forme JADE
- Une bibliothèque de classes que les programmeurs peuvent utiliser (directement ou
en les spécialisant) pour développer leurs agents ;
- Une suite d’outils graphiques qui permet d’administrer et de surveiller l’activité
courante des agents.
La figure 1 illustre, à travers un exemple, les notions définies ci-dessus. Cet exemple
montre deux plateformes JADE composées respectivement d’un et de trois conteneurs.
Les agents JADE sont identifiés par un nom unique. Grâce à la connaissance de leurs noms
respectifs, les agents peuvent communiquer de façon transparente, sans avoir à prendre
en considération la localisation de chacun : même conteneur (exemple des agents A2 et
A3), conteneurs différents au sein de la même plateforme (exemple des agents A1 et A2)
ou plateformes différentes (exemple des agents A4 et A5).
82
Annexe : La plate-forme JADE
Une plateforme d'agents peut être répartie sur plusieurs serveurs. Une seule
application Java, et donc une seule machine virtuelle de Java (JVM), est exécutée sur
chaque serveur.
10
Remote Method Invocation (Méthode d’invocation à distance).
83
Annexe : La plate-forme JADE
autres un certain JessBehaviour qui permet la pleine intégration dans JESS, où JADE fournit
le GUI de l'agent et garantit la conformité de FIPA, alors que JESS est le moteur qui
exécute tout le raisonnement nécessaire. On a donc la possibilité de créer des agents
intelligents en délégant le raisonnement à d'autres outils.
84
Annexe : La plate-forme JADE
1.4 - Les Agents de base
Pour supporter la tâche difficile du débogage des applications Multi-Agent, des outils
ont été développés. Chaque outil est empaqueté comme un agent, obéissant aux mêmes
règles, aux mêmes possibilités de communication et aux mêmes cycles de vie d’un agent
générique.
85
Annexe : La plate-forme JADE
des identifiants d’agents (AID) et de leurs états respectifs. Chaque agent doit
s’inscrire auprès de l’AMS pour obtenir un AID valide.
3. Agent Communication Canal « ACC » (canal de communication) : c’est le composant
logiciel qui contrôle tous les échanges de messages dans la plateforme, incluant
également les messages de/vers des plateformes distantes. L’agent ACC doit aussi
être compatible avec le protocole IIOP11 pour assurer l’interopérabilité entre les
différentes plateformes.
4. Directory Facilitor « DF » (facilitateur d’annuaire) : c’est l’agent fournissant un
service de pages jaunes à la plateforme. Grace à ce service, un agent peut connaître
les agents capables de lui fournir les services qu’il requiert pour atteindre son but.
L’interface du DF peut être lancée à partir du menu du RMA, cette action est en fait
implémentée par l’envoi d’un message ACL au DF lui demandant de charger son
interface graphique. L’interface peut être juste vue sur l’hôte où la plateforme est
exécutée. En utilisant cette interface, l’utilisateur peut interagir avec le DF : voir la
description des agents enregistrés, ajouter ou supprimer des agents, modifier la
description sur les agents enregistrés ou chercher la description d’un agent.
11
Le protocole IIOP, compatible avec la norme FIPA 1997, pour connecter les différentes plateformes
multi-agents.
86
Annexe : La plate-forme JADE
5. Dummy Agent « DA » : l'outil DummyAgent permet aux utilisateurs d'interagir avec
les agents JADE d'une façon particulière. L'interface permet la composition et
l'envoi de messages ACL et maintient une liste de messages ACL envoyés et
reçus. Cette liste peut être examinée par l'utilisateur et chaque message peut être
vu en détail ou même édité. Plus encore, le message peut être sauvegardé sur
le disque et renvoyé plus tard. Plusieurs instances du DummyAgent peuvent être
lancées de la barre de menu du RMA.
87
Annexe : La plate-forme JADE
88
Annexe : La plate-forme JADE
2 - Cycles de vie d’un agent JADE
Un agent JADE peut, à un instant donné, être dans l’un des états établis par la spécification
FIPA relative au cycle de vie de la plateforme d’agents. Ces états sont :
AP_INITIATED : l’agent est créé, mais ne s'est pas encore enregistré à l'AMS, il n'a ni
nom ni adresse et ne peut pas communiquer avec d'autres agents.
AP_ACTIVE : l’agent est inscrit à l'AMS, a un nom et une adresse réguliers et peut
accéder à tous les dispositifs de JADE.
AP_SUSPENDED : l’agent est actuellement arrêté. Son thread est suspendu et aucun
de ces comportements (Behaviour) n'est exécuté.
AP_WAITING : l'agent est bloqué, il attend quelque chose. Son thread est en
sommeil et se réveillera dès qu’une condition sera vérifiée (exemple : l’arrivée d’un
message).
AP_DELETED : l'agent est mort. Le thread correspondant a terminé son exécution et
l'agent n’est plus inscrit à l'AMS.
AP_TRANSIT : un agent mobile est dans cet état lorsqu’il migre vers un nouvel
emplacement. Le système continue à stocker ses messages qu’il lui transmettra
à son nouvel emplacement.
AP_COPY : cet état est exécuté par JADE pour cloner un agent.
89
Annexe : La plate-forme JADE
AP_GONE : cet état est exécuté par JADE quand un agent mobile migre à un nouvel
endroit et a un état stable.
La classe « Agent » fournit des méthodes publiques pour exécuter des transitions entre
les divers états ; ces méthodes sont conforment aux spécifications de la FIPA pour
la gestion des agents. À titre d’exemples :
La méthode doWait() (correspond à la fonction sleep() pour les threads de java) fait
passer l’agent de l’état AP_ACTIVE à l’état AP_WAITING.
La méthode doSuspend() fait passer l’agent de l’état AP_ACTIVE ou AP_WAITING à
l’état AP_SUSPENDED.
Notons qu’il n’est permis à un agent d’exécuter ses comportements ou tâches
(Behaviours) que lorsqu’il est dans l’état AP_ACTIVE.
90
Annexe : La plate-forme JADE
Un des dispositifs les plus importants que les agents JADE fournissent est la capacité
de communiquer. Le paradigme de communication adopté est le mode asynchrone.
Chaque agent a une sorte de boîte aux lettres (la file d'attente de messages de l’agent).
91
Annexe : La plate-forme JADE
A chaque fois qu’un message arrive, il est ajouté à la queue de la file et l’agent commence
par traiter le premier message arrivé.
Les messages échangés par les agents JADE obéissent au format spécifié par le
langage ACL lequel a été défini par la norme FIPA pour l'interopérabilité des agents.
4. 1 - Envoi de messages
msg.setLanguage ("Français");
msg.setOntology ("Prévision-météo");
92
Annexe : La plate-forme JADE
4.2 - Réception de messages
La lecture des messages de la file d'attente de message est accomplie par la méthode
receive() de la classe d'agent. Cette méthode renvoie le premier message dans la file
d'attente (en le retirant de la file) ou NULL si la file d'attente est vide.
L’exemple suivant défini la méthode action() d’un Behaviour ; dans cette méthode on
impose à l’agent de bloquer ce Behaviour par la méthode block() si aucun message n’est
reçu pour ne pas occuper le CPU, sinon on traite le message.
if (msg != null) {
else {
93