Rapport Supervision pdf

Conception et Réalisation d’un Système de Supervision Informatique à base d’Agents Mobiles BOUSSALEM Assam ZERARA Younes 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

Mémoire de fin d’études Pour l’obtention du diplôme d’Ingénieur d’Etat en Informatique

Option : Systèmes Informatiques

Thème Conception et Réalisation d’un Système de Supervision Informatique à base d’Agents Mobiles

Réalise par

Encadré par

-

Mr. BOUSSALEM Assam

-

Mr. HAFRI Younes

-

Mr. ZERARA Younes

-

Mr. MENACER Djamel-Eddine

PROMOTION : 2007/2008

INSTITUT NATIONAL D’INFORMATIQUE

Conception et Réalisation d’un Système de Supervision Informatique à base d’Agents Mobiles

BOUSSALEM Assam ZERARA Younes INEODEV Limited / INI

MEMOIRE PRÉSENTÉ EN VUE DE L'OBTENTION DU DIPLÔME D’INGENIEUR D’ETAT EN INFORMATIQUE (SYSTEMES INFORMATIQUES) SEPTEMBRE 2008

© BOUSSALEM Assam, ZERARA Younes, 2008.

Remerciement AU NOM DE DIEU TOUT PUISSANT, CLEMENT ET MISERICORDIEUX 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. Notre reconnaissance va particulièrement à Melle. CHEURFI Halima, Melle. BOULEFAAT Habiba, Melle. MEDJADBA Sanaa, Mr. DEMIL Rezki et Melle. AIT ADDA Samia, pour leurs aides et conseils. 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 Pour leurs soutien et encouragements. A mes proches et toute ma famille. A mes amis et tous les gens qui m’aiment. A tous ceux qui sont proches de mon cœur et dont je n’ai pas cité le nom. Au bonheur des plus chers. Je dédie ce modeste travail.

Assam Je dédie cet humble travail, À mes très chers parents, pour leurs amour et sacrifices, À mes adorables sœurs ; Imene, Asma et Aya pour leur patience, À mes proches amis et toute ma grande famille, pour leurs soutient et encouragements, À toutes les personnes qui connaissent Assam de prés ou de loin, et surtout, À Okba, Noureddine, Nabil, Khaled, Imane, Adel et Souad, Seulement pour leur existence.

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.

Le présent travail consiste à l’étude d’une architecture basé sur les agents mobiles orientée ‘’Monitoring Informatique’’. Dans ce cadre, nous allons présenter les notions de base de la supervision informatique et ses logiciels les plus utilisés actuellement, puis nous étudierons le nouveau paradigme multi-agent, ainsi que le concept d’agent mobile; et nous proposerons une architecture alternative que nous évaluons et critiquons par la suite.

Mots clés : Agent, système multi-agents, agent mobile, système de supervision/monitoring.

VI

Sommaire

Liste des figures ...................................................................................................................... XI Introduction générale ............................................................................................................... 1 1. Contexte de travail ..............................................................................................................1 2. Problématique ................................................................................................................... 2 3. Objectifs ............................................................................................................................. 3 4. Organisation du mémoire ................................................................................................. 3

PARTIE 1: Etat de l'art Chapitre 1 : La Supervision Informatique ................................................................................ 5 1 Introduction ............................................................................................................................ 5 2 Définition de la supervision informatique ........................................................................... 5 3 Fonctionnalités et niveaux d’information ............................................................................ 6 3.1 Informations sur les systèmes ..................................................................................... 7 3.2 Informations sur les réseaux ....................................................................................... 7 3.3 Informations sur les applications et services ............................................................. 7 4 Rôle de la supervision ............................................................................................................ 7 5 Aspects de la supervision ......................................................................................................8 6 Protocole SNMP .....................................................................................................................8 6.1 Définition du protocole SNMP ........................................................................................ 9 6.2 Principe de fonctionnement du protocole SNMP ......................................................... 9 6.3 SNMP en pratique.......................................................................................................... 10 7 Conclusion .............................................................................................................................. 11

Chapitre 2 : Les Systèmes de Monitoring Existants ..............................................................12 1 Introduction ...........................................................................................................................12 2 Le marché de la supervision .................................................................................................12 2.1 Les offres éditeurs .......................................................................................................... 12 2.1.1 HP OpenView ............................................................................................................13

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

Chapitre 3 : Le concept Agent ................................................................................................ 23 1 Introduction .......................................................................................................................... 23 2 Intelligence Artificielle Distribuée : .................................................................................... 24 2.1 Objectif de l’intelligence artificielle ............................................................................... 24 2.2 Orientation vers l’intelligence artificielle distribuée .................................................... 25 3 Notion d’Agent ..................................................................................................................... 26 3.1 Définition d’un Agent ..................................................................................................... 26 3.2 Principales caractéristiques d’un Agent ....................................................................... 27 3.3 L’Agent versus l’Objet ................................................................................................... 29 3.4 Principaux types des Agents ......................................................................................... 29 3.4.1 Les agents réactifs .................................................................................................. 29 3.4.2 Les agents cognitifs ................................................................................................ 30 3.4.3 Les agents hybrides .................................................................................................31 3.5 Architecture d’un Agent ................................................................................................ 32 3.6 Utilisation des agents .................................................................................................... 33 4 Les Systèmes Multi-Agents ................................................................................................. 33 4.1 Qu’est-ce qu’un Système Multi-Agents ? ...................................................................... 34 4.1.1 Définition .................................................................................................................. 34 4.1.2 Caractéristiques des SMA ....................................................................................... 35 4.1.3 Types des SMA ........................................................................................................ 36 4.2 Méthodologie de conception des SMA ........................................................................ 36 4.3 Apport des SMA ............................................................................................................. 38 4.4 Intérêts des SMA ........................................................................................................... 38 4.5 Domaines d’application des SMA ................................................................................. 39

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

PARIE 2: Conception et Implémentation Chapitre 4 : Conception ...........................................................................................................51 1 Introduction ...........................................................................................................................51 2 Fonctions principales ............................................................................................................51 3 Vision proposée: Vers une supervision à base d’agents mobiles ..................................... 52 3.1 Utilisation d’un seul agent mobile pour la supervision ................................................ 52 3.2 Utilisation d’un agent pour la détection et un autre pour la réparation .................... 53 3.3 Détection avec NAGIOS et réparation par agent mobile ............................................ 54 Voie choisie : Le deuxième scénario ................................................................................... 55 4 Conception............................................................................................................................ 56 4.1 Phase 1 : Analyse ............................................................................................................. 56 4.2 Phase 2 : Conception ..................................................................................................... 58 4.2.1 Schéma général du système ................................................................................... 58 4.2.2 Principe de fonctionnement :................................................................................. 59 4.3.3 Entités et modules du système : ............................................................................ 61 4.3.4 Description des agents du système....................................................................... 62 4.3.5 Schéma d’interaction Inter-Agents........................................................................64 5 Conclusion .............................................................................................................................66

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

Bibliographie et Web-graphie ..........................................................................................….77

Annexe : La plate-forme JADE................................................................................................ 81

X

Liste des figures

Liste des figures Figure 1: Fonctionnalités de la supervision................................................................................. 6 Figure 2: Eléments de base du protocole SNMP.......................................................................10 Figure 3 : Fonctionalités de Nagios. ........................................................................................... 17 Figure 4 : Architecture de NAGIOS. ...........................................................................................18 Figure 5 : Fonctionnement d’un Plugin de NAGIOS. .................................................................19 Figure 6 : Schéma général de fonctionnement d'un système de monitoring actuel. ........... 20 Figure 7 : Schéma d’un système de monitoring à base d’agents mobiles. ............................. 21 Figure 8: Fonctionnement d’un agent réactif. ......................................................................... 30 Figure 9: Modules d’un agent cognitif. ..................................................................................... 31 Figure 10: Tableau comparatif entre les agents cognitifs et réactifs....................................... 31 Figure 11: Structure d’un agent hybride en trois couches. ...................................................... 32 Figure 12: Architecture générale d’un agent. ........................................................................... 32 Figure 13: Représentation symbolique d’un SMA. ................................................................... 34 Figure 14: Les phases de développement de SMA. ................................................................. 36 Figure 15: Domaines d’application de la technologie SMA. .................................................... 40 Figure 16: Le schéma client/serveur.......................................................................................... 45 Figure 17: Le fonctionnement du schéma client/serveur. ....................................................... 46 Figure 18: Le schéma Evaluation distante. ............................................................................... 47 Figure 19: Le schéma Code à la demande................................................................................. 47 Figure 20: Le schéma Agent mobile. ........................................................................................ 48 Figure 21: Paradigme d’agents mobiles. ................................................................................... 49 Figure 22: Utilisation d’un seul agent mobile pour la supervision. ......................................... 53 Figure 23 : Utilisation d’un agent pour la détection et un autre pour la réparation.............. 54 Figure 24: Détection avec NAGIOS et réparation par agent mobile. ...................................... 55 Figure 25: Schéma général du système. ................................................................................... 58 Figure 26: Principe de fonctionnement. ................................................................................... 59 Figure 27 : Entités et composantes du système........................................................................61 Figure 28 : Agent de gestion. .................................................................................................... 62 Figure 29 : Agent d’analyse. ...................................................................................................... 63 Figure 30 : Agent de réaction. ................................................................................................... 64 Figure 31: Schéma d’interaction inter-agents. ......................................................................... 64 Figure 32: Diagramme d’interaction inter-agents .................................................................... 65 Figure 33: Environnement de développement. ....................................................................... 67 Figure 34: Intégration de JADE et SNMP4J avec Eclipse......................................................... 70 Figure 35: Le moniteur JADE RMA. ............................................................................................ 71 Figure 36: L’interface utilisateur MAMS. .................................................................................. 72 Figure 37 : Le client de supervision. .......................................................................................... 73 Figure 38: Les services supervisés. ........................................................................................... 74 Figure 39: Les nœuds supervisés. ............................................................................................. 75

XI

Introduction générale

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. L’apparition de ces nouveaux environnements informatisés rend la surveillance des éléments clefs de réseau et de système une opération indispensable, afin de minimiser la perte d’exploitation et garantir que les utilisateurs ne s’aperçoivent pas des anomalies de fonctionnement. Ces anomalies provoquent des conséquences variables en degré pour le fonctionnement au niveau de système d’entreprise. En effet, l’arrêt d’un service de messagerie n’est pas aussi couteux que la perte de la base de données de son entreprise due à un disque défectueux [REU, 04]. Vu que le système informatique est au cœur des activités d’entreprise, sa maitrise devient primordiale, puisque, il doit fonctionner pleinement et en permanence pour garantir la fiabilité et l’efficacité exigées, d’une part. D’autre part, les problèmes liés au système informatique tels que les défaillances, les pannes, les coupures et les différents problèmes techniques doivent être réduits, du fait qu’une indisponibilité du système ou du réseau peut causer des pertes considérables. Afin de minimiser le nombre de ces pertes, une sorte de surveillance et de contrôle s’avère obligatoire ; la notion de la « supervision informatique » fût apparue et devenue une tâche vitale pour tout système informatique. Cette nouvelle branche d’administration système/réseau doit assurer trois fonctionnalités : -

garantir la disponibilité de leurs système et réseau ; tenter de prévenir en cas de problème ; garantir une durée d’intervention et de résolution minimale.

1

Introduction générale En résumé, le but majeur attendu d'un système de supervision (Monitoring system : en Anglais) est d’assurer le plus possible le bon fonctionnement du système informatique, en surveillant les services et les entités logicielles (software) ainsi qu’en contrôlant le matériel (hardware).

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. De plus, il y a souvent peu d’informations disponibles pour aider les administrateurs à comprendre les problèmes actuels et à prévoir les défaillances du système. Donc, il peut leur être difficile d’atteindre les niveaux de service requis par l’entreprise. 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. On est ainsi naturellement conduit à chercher à donner plus d’autonomie et d’initiative aux différents modules logiciels. Le concept de système multi-agent propose un cadre de réponse à ces deux enjeux : autonomie et organisation [DEM, 01].

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 : 1. 2. 3. 4. 5.

Etudier les systèmes de supervision et leurs principes. Comprendre le paradigme agent et tout ce qu’il en découle. Montrer les avantages et l’apport des agents mobiles dans ce type de logiciels. Proposer une architecture à base d’agents mobiles pour la supervision. Tester et estimer cette architecture.

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. Pour cela, nous avons organisé le manuscrit de la façon suivante : 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 multiagents et des agents mobiles. II. La deuxième partie est constituée de deux chapitres : 4. Conception: c’est une présentation d’un modèle d’application et description des différents sous systèmes de l’architecture qu’on va proposer. 5. Implémentation : c’est une mise en pratique de la conception et l’implantation des théories dans un environnement réel. 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

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.

2 Définition de la supervision informatique En informatique, la supervision est une technique de suivi, qui permet de surveiller, analyser, rapporter et d’alerter les fonctionnements normaux et anormaux des systèmes informatiques.

5

Chapitre 1


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].

3 Fonctionnalités et niveaux d’information Généralement, les moniteurs de supervision regroupent les fonctionnalités illustrées dans la figure suivante [Lien 5]:

Figure 1: Fonctionnalités de la supervision.

Supervision réseau2 : elle porte sur la surveillance de manière continue de la disponibilité des services en ligne, du fonctionnement du réseau, des débits et bande passante, de la sécurité, etc. Supervision système : c’est la vérification de la santé d'un serveur coté ressources matérielles (la mémoire, le CPU, le disque dur, etc.). Exécution de commandes : qui sont des actions ou programmes lancés automatiquement. Envoi d'alertes : c’est une émission de message d’alerte sous forme sonore, visuelle ou encore par e-mail.

1

Monitoring : mot en Anglais qui désigne la surveillance ou la supervision.

2

http://fr.wikipedia.org/wiki/Supervision

6

Chapitre 1


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]:

3.1 Informations sur les systèmes Cette supervision fournira des informations sur le fonctionnement du système comme l'utilisation du CPU, l’occupation de la mémoire physique, l’espace libre des disques dures, l’état de la table de partitionnement du disque, la chaleur dégagée, etc.

3.2 Informations sur les réseaux Ce type de surveillance va permettre de diagnostiquer la disponibilité d’un équipement physique connecté à un réseau. Les technologies employées pour ce type de supervision sont assez simples et le niveau des informations retournées est assez limité. Les matériels visés sont : les commutateurs, les routeurs et les serveurs (disponibilité, interrogation des sondes, alertes), ainsi que les onduleurs (disponibilité, charge, état) et les imprimantes (disponibilité, état de l’imprimante et des consommables).

3.3 Informations sur les applications et services On va disposer non seulement d'une visibilité sur l’équipement physique mais également sur les applications qui y sont exécutées et les informations qu’elles retournent. Ses principaux axes sont : la disponibilité, le nombre d’utilisateurs, la cohérence des réponses aux interrogations et les performances. Pour les deux derniers cas, les tests devront être effectués par des équipements qui ne sont pas sur la machine, car le serveur est destiné à des utilisateurs externes (par exemple serveur Web connecté à Internet). Le monitoring informatique fournira dans ce contexte, une vision utilisateur depuis les endroits où il est effectué. Par exemple, le monitoring réseau permet la vérification de la connectivité d’un serveur Web, qui rend les sites Web accessible par les internautes. Ou encore le monitoring applicatif qui permet la vérification de l’opérationnalité d’un serveur (Apache ou IIS par exemple) et celle du contenu des pages Web.

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


-

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 ;

-

Automatiser les tâches de récupération des applications et des services en assurant des mécanismes de redondance en une durée d'intervention minimale (par exemple : le redémarrage des services interrompus, l’arrêt de la machine en cas du surcharge du CPU, la sauvegarde des données en cas du risque de perte d’un disque dure en miroir, etc.).

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]: 1. La Fiabilité : Il s’agit de l’utilisation la plus courante du monitoring informatique. Une surveillance permanente de la disponibilité de l’équipement est effectuée, et ce pour détecter la moindre anomalie et de la signaler à l’administrateur. 2. La Performance : Le monitoring de performance a pour but de retourner des informations sur le rendement d’un équipement ou d’un service comme par exemple le temps de résolution DNS, le temps de connexion, le temps de récupération du premier octet et dans le cas d’une page Web le temps de récupération de la page et de l’ensemble des éléments de celle-ci (image, scripts…). Grâce à cette analyse, on va pouvoir diagnostiquer une montée en charge difficile ou même un surdimensionnement de votre bande passante. 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. Toutes ces approches sont complémentaires et peuvent bien entendu se retrouver regroupée dans une seule analyse. L’analyse Fiabilité étant implicitement présentée dans le cas d’une analyse Performance et Contenu.

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


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.

6.1 Définition du protocole SNMP SNMP est l’abréviation du ‘’protocole simple de gestion de réseau’’. Comme son nom voudrait le faire croire, Il s'agit d'un protocole simple qui permet aux administrateurs réseau de gérer les équipements du réseau et de diagnostiquer les problèmes de réseau [Lien 10].

6.2 Principe de fonctionnement du protocole SNMP Avec le protocole SNMP, le système de gestion de réseau est basé sur trois éléments principaux : un superviseur, des agents et les nœuds gérés. Le superviseur est la console qui permet à l'administrateur réseau d'exécuter des requêtes de management. Les agents sont des entités qui se trouvent au niveau de chaque interface qui connecte l’équipement managé au réseau et qui permette de récupérer des informations sur différents équipements tels que les switchs, les hubs, les routeurs et les serveurs contenant des objets gérables via SNMP. Ces derniers peuvent être des informations matérielles, des paramètres de configuration, des statistiques sur les performances ou encore tout autre objets directement liés au comportement en cours de l’équipement concerné. Ces objets sont classés dans une sorte de base de données nommée MIB ("Management Information Base") qui est un ensemble d'informations structuré hiérarchiquement sur une entité réseau. Les informations sont regroupées en arbre [Lien 9]. SNMP permet le dialogue entre le superviseur et les agents afin de recueillir les objets souhaités dans la MIB [Lien 10]. L'architecture de gestion de réseau proposée par le protocole SNMP est donc basée sur trois principaux éléments : 1. Les équipements managés : ce sont des éléments du réseau (ponts, hubs, routeurs ou serveurs), contenant des "objets de gestion" pouvant être des informations sur le matériel, des éléments de configuration ou des informations statistiques ; 9

Chapitre 1


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:

Figure 2: Eléments de base du protocole SNMP.

6.3 SNMP en pratique Concrètement, dans le cadre d'un réseau, SNMP est utilisé: pour administrer les équipements et pour surveiller le comportement des équipements [Lien 11]. Une requête SNMP est un datagramme UDP3 habituellement à destination du port 161. Les schémas de sécurité dépendent des versions de SNMP (v1, v2 ou v3). Dans les versions 1 et 2, une requête SNMP contient un nom appelé communauté, utilisé comme un

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


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

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).

2.1 Les offres éditeurs Les gros éditeurs logiciels ont rapidement compris que la supervision était une ressource clé pour les entreprises qui, de plus en plus, utilisent leur système d'information et ont donc besoin d'une disponibilité toujours plus grande de leur infrastructure informatique. Par conséquent, la supervision est un domaine dans lequel les sociétés n'hésitent pas à investir depuis quelques années. Ayant rapidement compris cela, les gros éditeurs logiciels sont donc très vite entrés dans la course aux logiciels de supervision. Aujourd'hui, la majorité des gros éditeurs logiciels propose des outils complets de supervision. On retrouve, parmi les plus connus : •

HP : la gamme Openview (NNM, OVO, ...); IBM : Tivoli ; BMC : Patrol ; Computer Associates : Unicenter TNG . 12

Chapitre 2


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 …).

Les agents OVOW OVOW a besoin d’un agent pour pouvoir surveiller un élément. Un agent OVOW est un programme que l’on déploie à partir du serveur HPOV sur un nœud. On doit spécifier à cet agent un domaine cible (Que doit-on surveiller ?). 13

Chapitre 2


L'agent OVOW est composé d'une mini base de données très sécurisée nommée base Coda. L’agent stocke ses les informations liées aux métriques de performances du matériel surveillé dans la base Coda ensuite le serveur se connecte à cette base toutes les 4 minutes (variable paramétrable), et récupère les informations et les stockent dans sa base SQL SERVER.

2.1.2 IBM Tivoli Monitoring Les solutions IBM Tivoli Monitoring sont conçues pour une meilleure gestion des applications en ligne essentielles à l’entreprise en : •

surveillant de manière proactive les ressources système vitales ;

•

en détectant efficacement les goulets d’étranglement et les problèmes potentiels ;

•

en répondant automatiquement aux événements.

En s’appuyant sur les meilleures pratiques pour identifier et résoudre les problèmes d’infrastructure, il a été conçu pour aider les opérateurs à surveiller et gérer les matériels et logiciels essentiels, comprenant les systèmes d’exploitation, les bases de données et les applications sur des environnements répartis [Lien 13]. Ce moniteur de supervision se classe parmi les leaders du domaine, puisque il offre de nombreux avantages. En effet, il : Surveille de manière proactive les composants vitaux de votre infrastructure à la demande, en vous aidant à isoler et prévenir rapidement les problèmes de performance ; Visualise les mesures de performances historiques et en temps réel sous forme de tableaux et graphiques, avec en plus des conseils spécialisés et des actions automatiques au sein d’IBM Tivoli Enterprise Portal ; Consolide la surveillance et la gestion de systèmes répartis et de systèmes hôte à l’aide d’une seule console de travail personnalisable ; Fournit des outils de surveillance puissants et personnalisables à davantage d’opérateurs nécessitant beaucoup moins de compétences et formation en programmation pour déployer le produit ; Aide à réduire les coûts opérationnels informatiques globaux en simplifiant l’installation et la configuration, et en déployant des règles allégées avec des fonctionnalités de surveillance automatique ; Effectue automatiquement le suivi de l’état des principaux composants de votre environnement informatique complexe et reçoit des alertes uniquement en cas d’incident ;

14

Chapitre 2


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].

2.2 Les offres du monde libre Depuis une dizaine d'années déjà, plusieurs projets de supervision ont vu le jour au sein de la communauté du logiciel libre. Il suffit pour cela d'aller faire une simple recherche sur le Net pour se rendre compte de la multitude de projets émergeants autour de la supervision système et réseau. Nous présenterons ainsi, les systèmes de monitoring plus populaires [Lien 4]: NAGIOS ou Net saint4 (qui sera détaillé par la suite) est le principal logiciel Open Source de supervision de réseaux et de systèmes; c’est le plus rependu et le plus suivi par la communauté de développeurs. Par conséquent, il est adapté aux systèmes d’information de taille moyenne ou importante ; MRTG est un outil de supervision du trafic de liens réseaux. Il peut s'intégrer étroitement à des solutions comme Nagios. MRTG (Multi Router Traffic Grapher) génère des pages HTML de représentation en temps réel du trafic réseau. Le logiciel prend toute sa dimension comme produit fini, mais également comme brique spécialisée d'une solution intégrée plus large. Il s'intègre notamment parfaitement dans la solution de supervision de Nagios. Son architecture logicielle permet l'intégration sur des plates-formes et composants hétérogènes. CACTI est un logiciel de supervision réseau basé sur RRDTool. Il peut-être considéré comme un successeur à MRTG et également comme une interface à RRDTool. Cacti permet de représenter graphiquement divers statuts de périphériques réseau utilisant SNMP ou encore grâce à des scripts (Bash, PHP, Perl, VBs...) pour avoir par exemple l'espace disque restant ou bien la mémoire utilisée, la charge processeur ou le ping d'un élément actif. Les données sont récoltées auprès des différents agents SNMP (ou auprès des scripts locaux) grâce à un script php. Pour de meilleures performances un exécutable, nommé cactid, peut également effectuer les interrogations.

4

Net Saint : c’est l’ancienne appellation du NAGIOS

15

Chapitre 2


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 celuici est résolu ;

16

Chapitre 2


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]:

Figure 3 : Fonctionalités de Nagios.

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


1. L’ordonnanceur : c’est le moteur de l’application l’ordonnancement des tâches de supervision.

qui

s’occupe

de

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]:

Figure 4 : Architecture de NAGIOS.

3 Principes de bases de Nagios Les Common Gate Interface (CGI) : C’est une technologie standard implémenté à tous serveurs Web. Elle permet l’échange de données entre un programme et le contenu d’une page Web visualisée par un internaute distant. Un tel programme peut être écrit à l’aide de n’importe quel langage de programmation : les plus utilisée sont le langage C, Perl ou encore Python.

Les Plugins : A la différence de beaucoup d’autres outils de supervision. Nagios ne dispose pas de mécanisme interne pour vérifier l’état d’un service, d’un hôte…etc. Il utilise des programmes externes appelés Plugins, Les Plugins sont des programmes exécutables ou scripts (Perl, Shell, Etc.) qui peuvent être lancés depuis une ligne de commande pour tester un hôte ou un service. Nagios utilise le résultat 18

Chapitre 2


de cette action pour déterminer le statut des hôtes ou services sur le réseau. Pour Nagios peut importe peut importe ce que fait un Plugin, seul le résultat compte. Les Plugins permettent aux utilisateurs de développer facilement leurs propres vérifications de services. Ces plugins fonctionnent soit en local sur la machine supervisée, soit exécutent des tests à distance (Tels sur des protocoles réseaux tels Http, Smtp ou exécution distante via Ssh ou autres). Ce concept est illustré dans la figure suivante [Lien 15]:

Figure 5 : Fonctionnement d’un Plugin de NAGIOS.

4 Mise en réseau de la supervision avec Nagios Les plugins locaux au serveur de supervision sont exécutés directement par Nagios. La vérification d’un service à distance (par l’exécution d’un Plugin situé sur une autre machine ou par SNMP) se fait elle aussi par le biais de l’exécution d’un Plugin local au serveur Nagios qui n’est en faite qu’un ordonnanceur de tâches dédiés à la supervision. Nagios n’a pas pour vocation d’intégrer des fonctionnalités de vérification de bon fonctionnement quelconques autres que ses fonctions internes [Lien 14]. Pour l’exécution de plugins à distance, plusieurs possibilités existent: Par le biais d’autres serveurs de supervision Nagios distants : dans le cas de la supervision distribuée qui concentrent la vérification sur un site distant, et ne remontent que les problèmes. Les agents de transport ou d’exécution des tests, tels [Lien 14]: 1. NRPE (Nagios Remote Plugin Executor) qui permet l’exécution à la demande de Plugins à distance, à choisir parmi un certain nombre de services disponibles. C’est ce qu’on appelle la supervision active.

19

Chapitre 2


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.

3 Limite des systèmes actuels Toutes les solutions de supervision actuelles se focalisent à : Effectuer des vérifications locales ou distantes sur les machines et/ou services du réseau. Récupérer les résultats de ces vérifications pour ensuite informer les administrateurs sur l’état des services de leurs systèmes informatiques. En cas d’une anomalie, le logiciel de supervision ne peut rien et l’intervention humaine est indispensable pour le bon fonctionnement du système. Et bien que Nagios soit un logiciel de monitoring plutôt réussit, et offrant diverses fonctionnalités, il ne fait pas exception à la coutume quand il s’agit d’anomalies et problèmes dans les systèmes surveillés. Il se contente de récupérer les résultats retournés par les Plugins définis et de les afficher sur écran afin de délivrer une information simple et fiable à l’utilisateur, ce dernier intervient manuellement pour résoudre ces pannes. La figure suivante représente le fonctionnement général d’un outil de monitoring :

Figure 6 : Schéma général de fonctionnement d'un système de monitoring actuel.

20

Chapitre 2


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 plateforme à 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):

Figure 7 : Schéma d’un système de monitoring à base d’agents mobiles.

5

La technologie d’agent (particulièrement : l’agent mobile) sera être décrite dans le chapitre suivant.

21

Chapitre 2


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

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 multiagents 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.

2 Intelligence Artificielle Distribuée : John McCarthy a introduit l’Intelligence Artificielle (IA) en 1955. Il l’a définit comme suit : « L’Intelligence Artificielle a pour but de faire exécuter par l’ordinateur des tâches pour lesquelles l’homme, dans un contexte donné, est aujourd’hui meilleur que la machine », [SAB, 01].

2.1 Objectif de l’intelligence artificielle Pour recouvrir des domaines vastes et complexes, l’application de l’intelligence artificielle (IA) a été évoluée. Elle sert à définir des systèmes capables de représenter des connaissances, de raisonner ou planifier des actions afin de résoudre des problèmes pouvant être très complexes tels que l’aide à la discision, la reconnaissance et la compréhension des formes, la conduite des processus industriels, etc. Principalement, l’IA vise à obtenir des résultats comparables et proches (voire même meilleurs) de ce que feraient des êtres humains dans des cas similaires, et ceci bien entendu, sans avoir à recourir forcement aux mêmes moyens. 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.

3.1 Définition d’un Agent Jusqu’à présent, on ne peut pas trouver une définition universelle d’un agent, mais plutôt une multitude de définitions, elles se ressemblent toutes, quoique elles se différent suivant le type d’application pour laquelle est conçu l’agent. a. A titre d’exemple, nous citons l’une des premières définitions de J. FERBER : « Un agent est une entité autonome, réelle ou abstraite, qui est capable d’agir sur elle-même et sur son environnement, qui, dans un univers multi-agents, peut communiquer avec d’autres agents, et dont le comportement est la conséquence de ses observations, de ses connaissances et des interactions avec les autres agents. » [FER, 97]. En d’autres termes, J. FERBER le redéfinit comme suit : « Un agent est une entité physique ou virtuelle : 1. qui est capable d’agir dans un environnement, 2. qui peut communiquer directement avec d’autres agents, 3. qui est mue par un ensemble de tendances (sous la forme d’objectifs individuels ou d’une fonction de satisfaction, voire de survie, qu’elle cherche à optimiser), 4. qui possède des ressources propres, 5. qui est capable de percevoir (mais de manière limitée) son environnement, 6. qui ne dispose que d’une représentation partielle de cet environnement (et éventuellement aucune), 7. qui possède des compétences et offre des services, 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.

3.2 Principales caractéristiques d’un Agent Il est important de déterminer les différentes caractéristiques que doit posséder un agent et qui font la différence avec les programmes conventionnels. En effet, dépendamment des situations et des circonstances, un agent peut être fortement caractérisé par un sous-ensemble des propriétés indiquées ci-dessous et être difficilement associable aux autres spécifications. Voici les principales caractéristiques [OLI, 98], [ROU, 04]: 1- Autonomie : un agent a un certain degré d'autonomie, c'est-à-dire qu’il possède certains états (non accessibles aux autres agents et composants du système) et qu’il peut prendre certaines décisions par rapport à ses états (sans intervention externe 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 ; 4- Pro-activité : les agents n’agissent pas seulement en réponse à leur environnement,

mais ils sont également capables d’avoir un comportement guidé par un but, en ayant la possibilité de prendre l’initiative ; 5- Activité : un agent est toujours actif. Il s'exécute donc nécessairement dans un thread

ou un processus indépendant ; 6- Apprentissage : l’agent est capable d’apprendre et d’évoluer en fonction de cet

apprentissage, en le rendant capable de changer de comportement (en fonction des expériences passées). En fait, l’apprentissage est une caractéristique qui fournit aux systèmes la capacité d’acquérir la compréhension de certains comportements au cours du temps, sans nécessiter que ces comportements soient programmés manuellement; 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.

3.4 Principaux types des Agents La typologie des agents repose sur la granularité, c'est-à-dire la complexité des fonctionnalités que possède l’agent, et par conséquent, Il existe deux écoles distinctes [CHA, 01]: •

l’école réactive qui perçoit les agents comme des entités très simples réagissant directement aux modifications de l’environnement ;

•

l’école cognitive qui définit les agents comme des entités intelligentes.

Les types d’agents induits sont donc les agents réactifs et les agents cognitifs (ou délibératifs). D'autres types d'agents, qualifiés d'hybrides, utilisant donc ces deux types de comportement, sont ensuite apparus:

3.4.1 Les agents réactifs Les agents réactifs n'ont pas de représentation de leur environnement, de leur monde si ce n'est que très partiellement. Ils ont un comportement de type « stimulus/réponse ». Les actions consistent à réagir à des informations leur parvenant.

29

Chapitre 3

Le concept Agent

La figure 8 présente le fonctionnement d’un agent réactif [Lien 1] :

Figure 8: Fonctionnement d’un agent réactif.

Les défenseurs de cette approche partent du principe suivant : dans un système multiagent, 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].

3.4.2 Les agents cognitifs Les sociétés d’agents cognitifs sont composées d’un petit nombre d’agents de forte granularité (à grande capacité d’action) dont chacun est assimilable, suivant le niveau de ses capacités, à un système expert plus ou moins sophistiqué. Ces agents sont des agents communicants [DIE, 90]. L’agent cognitif est constitué d’une base de connaissances qui contient toutes les connaissances concernant son fonctionnement et son environnement. Cette base peut être mise à jour par de nouvelles connaissances acquises, par échange d’informations avec les autres agents ou par le biais de la perception sur son environnement. Contrairement aux agents réactifs, les agents cognitifs possèdent : une représentation globale et explicite de leur environnement, des autres agents avec lesquels ils communiquent et d’eux-mêmes ; des capacités de raisonnement sur leurs bases de connaissances, leurs intentions et leurs buts pour prendre des décisions suivant une planification.

30

Chapitre 3

Le concept Agent

La figure 9 montre les modules constituant un agent cognitif [Lien 2] :

Figure 9: Modules d’un agent cognitif.

La figure 10, nous montre un tableau comparatif entre les deux approches [ROU, 04]:

Systèmes d'agents cognitifs

Systèmes d'agents réactifs

Représentation explicite de l'environnement

Pas de représentation explicite

Peut tenir compte de son passé

Pas de mémoire de son historique

Agents complexes

Fonctionnement Stimulus/réponse

Petit nombre d'agents

Grand nombre d'agents

Figure 10: Tableau comparatif entre les agents cognitifs et réactifs.

3.4.3 Les agents hybrides Une architecture hybride d'un agent est une architecture composée d'un ensemble de modules organisés dans une hiérarchie, chaque module étant soit une composante cognitive avec représentation symbolique des connaissances et capacités de raisonnement, soit une composante réactive. De cette manière, le comportement proactif de l'agent, dirigé par les buts, est combiné avec un comportement réactif aux changements de l'environnement, afin d’obtenir simultanément les avantages des architectures cognitives et réactives, tout en éliminant leurs limitations [SEC, 03]. La plupart des architectures hybrides considèrent que trois couches suffisent amplement. Ainsi, au plus bas niveau de l’architecture, on retrouve habituellement une couche purement réactive, qui prend ses décisions en se basant sur des données brutes en provenance des senseurs. La couche intermédiaire fait abstraction des données brutes et 31

Chapitre 3

Le concept Agent

travaille plutôt avec une vision qui se situe au niveau des connaissances de l’environnement. Finalement, la couche supérieure se charge des aspects sociaux de l’environnement, c’est à dire du raisonnement tenant compte des autres agents [CHA, 01]. Ci-dessous, la structure d’un agent hybride est illustrée à travers la figure 10 : Couche cognitive Couches Intermédiaires Couche réactive Figure 11: Structure d’un agent hybride en trois couches.

3.5 Architecture d’un Agent La structure interne d’un agent logiciel n’est pas simple. Généralement, les agents ont une architecture qui leur permet d’être réactifs ou cognitif. La figure 11 montre cette architecture générale [ROU, 04] :

Figure 12: Architecture générale d’un agent.

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]: a. Les agents dans un réseau informatique : Un agent informatique est un programme qui s’exécute sur une machine, l’environnement d’exécution doit cependant fournir aux agents un moyen de communiquer entre eux. Les agents peuvent se déplacer d’une machine à l’autre, principalement en empruntant un réseau. b. Les assistants : Ce sont des agents qui travaillent pour et avec les utilisateurs. Les plus célèbres d’entre eux sont les assistants de Microsoft Office. En effet, l’assistant surveille tout ce que l’utilisateur fait et lui propose des astuces pour aller plus vite (raccourcis clavier, manipulations à la souris …). c. Les jeux : Des agents permettent de faire fonctionner les avatars, c'est-à-dire, les joueurs gérés par l’ordinateur. En effet, lorsque l’ordinateur qui joue, il y de fortes chances pour que se soit un agent qui joue. d. La robotique : Dans ce cas, on est plus dans le domaine de l’informatique. Le petit robot qui transporte des charges, la tendeuse ou la balayeuse automatique, ce sont des agents. e. L’attente d’information : Parfois, le problème n’est pas de savoir où se trouve l’information mais quand est- ce qu’elle va s’y trouver. Dans ce cas, les agents peuvent aussi se révéler utiles. Prenons l’exemple de cours boursiers : ce sont disponibles sur Internet (Bourse de New York, Yahoo-Finance…). On sait donc où est l’information, il faut maintenant savoir quand l’information va devenir intéressante. Ainsi, on peut envoyer un agent sur le serveur de la bourse en lui programmant d’attendre jusqu’à ce qu’une action atteigne un certain cours puis de revenir faire un rapport. Quand l’agent est sur le serveur de la bourse, il peut revenir à tout moment. Il existe deux cas : On reste connecté et l’agent revient faire un rapport dès que le cours est atteint. On ne reste pas connecté et l’agent attend que l’on se reconnecte pour faire son rapport.

4 Les Systèmes Multi-Agents L’agent en tant qu’entité individuelle peut s’avérer limité dans pas mal de cas, surtout en vue de ce que l’on connaît aujourd’hui comme applications distribuées et pour lesquelles un ensemble d’agents mettant en commun leurs compétences et connaissances parait plus que nécessaire. 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 Qu’est-ce qu’un Système Multi-Agents ? Pour se familiariser avec le concept de système multi-agents, nous avons jugé utile de voir sa définition, ses principales caractéristiques et ses types.

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] :

Figure 13: Représentation symbolique d’un SMA.

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]: « On appelle système multi-agents (ou SMA), un système composé des éléments suivants : un environnement E, c’est-à-dire un espace disposant généralement d’une métrique ; 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; un ensemble d’opérations Op, permettant aux agents de A de percevoir, produire, consommer, transformer et manipuler des objets de O; des opérateurs chargés de représenter l’application de ces opérations et la réaction du monde à cette tentative de modification, que l’on appelle les lois de l’univers. » 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 sousensembles, 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.

4.1.2 Caractéristiques des SMA Un SMA est caractérisé par [MBA, 03]: 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 ; Il n’existe aucun contrôle global du système ; Les données sont décentralisées (les agents agissent et travaillent indépendamment les uns des autres) ; Les traitements sont en mode asynchrone. 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).

4.1.3 Types des SMA On peut différencier les SMA selon le nombre d’agents, la nature et la complexité de ces agents. Ainsi, un SMA peut être soit [DRO, 05] : •

Ouvert : les agents y entrent et en sortent librement (par exemple: l’utilisation d’un SMA pour développer une application de commerce électronique).

•

Fermé : où l'ensemble d'agents reste le même.

•

Homogène : dont tous les agents sont construits sur le même modèle.

•

Hétérogène : dont les agents de modèles sont différents, c'est-à-dire de granularités différentes.

4.2 Méthodologie de conception des SMA L’intérêt d’une méthodologie de conception est de passer d’un cahier des charges à une implémentation, et de pouvoir gérer le cycle de vie globale d’une application. Tout ceci couvre des besoins comme la spécification initiale (besoin, analyse), l’architecture (conception), l’implémentation, mais encore l’expression des modèles utilisés dans un but de maintenance ou de réalisation. D’après [BRA, 87], les phases de développement de SMA sont : les besoins, l’analyse, la conception, l’implémentation et le test (Figure 14).

Besoins

Analyse

Conception

Implémentation

Test

Figure 14: Les phases de développement de SMA.

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. La méthodologie AEIO englobe à travers trois phases [PIC, 04]: a. Phase d'analyse : dans un premier temps, cette méthodologie consiste à identifier et décomposer le problème en quatre composantes fondamentales: Agents, Environnement, Interactions et Organisation, pour dégager l'architecture générale du système. b. Phase de conception : les quatre composantes A, E, I et O étant identifiées, elles constituent ainsi les spécifications globales du système multi-agents. Il s'agit, au cours de cette phase, de choisir les modèles opérationnels des composantes pour aboutir à la spécification du fonctionnement global du système exprimé sous forme de diagrammes de comportement. Les modèles d'agent ou architectures d'agents vont de modèles simples comme les automates à états finis (agents réactifs) aux modèles plus complexes comme les systèmes à base de connaissances (agents cognitifs). Les modèles d'environnement dépendent du domaine d'application, ils sont généralement spatialisés et dotés d'une métrique. Les structures et langages d'interaction vont des modèles issus de la physique, comme les modèles à base de forces, à des interactions de haut niveau basées sur la théorie des actes de langage. Enfin, les modèles d'organisations vont des modèles biologiques jusqu'aux modèles inspirés par les lois sociales.

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.

4.3 Apport des SMA Si les architectures et les applications actuelles basées sur les SMA manifestent des défauts, ils n'en sont qu'à leur début, et on peut affirmer, en plus, que la prochaine génération des systèmes informatiques sera construite autour de la technique des "agents logiciels". Leur comportement dynamique et leur capacité de voyager sur les réseaux en faisant l’outil de base pour le développement des applications "télécommunications" qui constitueront l’essentiel de l’activité informatique de demain. Il va être possible de maîtriser les réseaux, de coordonner de manière efficace des architectures décentralisées et d’amorcer de vraies bases de données réparties. C’est une vraie révolution technologique qui va bouleverser les méthodes traditionnelles de gestion des activités de la communication et du commerce. Au futur, on s’attend à voir un développement des infrastructures industrielles qui demandera sûrement des progrès informatiques pour répondre aux besoins de l’entreprise. Bref, l’intérêt de cette branche de l’intelligence artificielle distribuée soit montré, et qui offre une méthode de conception des systèmes que la plupart des logiciels d’ingénierie courants considèrent comme complexes. Cependant, la transition à partir de laboratoires de recherche vers des applications industrielles déployées est effectivement un challenge que vont relever les prochains développeurs de logiciels dans le domaine des systèmes multi-agents.

4.4 Intérêts des SMA Les principaux intérêts se résument ainsi: Ils s’adaptent bien à la réalité dans la mesure où de nombreux problèmes sont de nature distribuée ; l’utilisation de nombreux agents résolvant le même problème de façon différente, produit généralement des solutions de meilleure qualité en termes de complétude et de précision ; ils permettent d’intégrer des connaissances diverses et complexes; 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 ;

4.5 Domaines d’application des SMA Les systèmes multi-agents ont déjà montré des promesses particulières dans une variété de systèmes technico-sociaux comme: la gestion du trafic aérien, la gestion des ressources, les applications boursières, la télémédecine, l’environnement de robotique cognitive ou les systèmes de commande et de contrôle en temps réel, etc. 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.

La suivante figure (Figure 15) illustre les domaines d’application de la technologie SMA ainsi que les diverses disciplines qu’elle fait intervenir [Lien 8].

39

Chapitre 3

Le concept Agent

Figure 15:: Domaines d’application de la technologie SMA.

5 Les agents mobiles Les applications ions de traitement traiteme de l’information ont souvent exigé (et continuent à exiger) d'être de plus en plus distribuées sur de nombreux sites distants. Les systèmes distribués qui les supportent sont souvent basés sur le fameux modèle Client/Serveur. Client/Serveur Mais, le e volume d'informations d'informations manipulées par les différentes applications n'a pas cessé de croître ; et ce, à un rythme très accéléré dépassant largement le rythme des améliorations apportées aux réseaux. Pour cela, il était nécessaire de moderniser le modèle Client/Serveur afin de supporter supporter plus efficacement les interactions entre les clients et les serveurs et ce en améliorant les méthodes de communication existantes [GAR, 00]. Parmi les modèles modernisés, on trouve l’approche d’agent mobile. En effet, avec les travaux de J. WHITE chez General Magic [WHI, 95], le e monde des agents a été enrichi d’un nouveau type : les agents mobiles. mobiles Cela était en 1995, quand le le développement des agents mobiles a coïncidé avec le succès du langage Java qui permet d’offrir un environnement technique très favorable.

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 Qu’est ce qu’un agent mobile ? Nous entamerons ce paradigme d’agent mobile par sa définition.

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].

5.1.2 Attributs d’un agent mobile Un agent mobile est une entité qui possède cinq composants : son état, son implémentation (code), son interface, son identifiant et son autorité [MED, 07]: a. L’état : quand un agent se déplace, il transporte avec lui son état, ceci lui permet de reprendre son exécution quand il arrive à destination au point même où il l’avait quittée. L’état d’un agent peut être considéré comme une photo instantanée de son exécution. Dans la plupart des langages de programmation, on peut partitionner cet état en : 1. Un état d’exécution : instruction en cours (compteur) + pile ; c’est les valeurs des variables qui peuvent aider à déterminer la suite de l’exécution après migration. 2. Un état d’objet : contient les valeurs des variables d’instance dans un objet. b. L’implémentation (code) : comme n’importe quel autre programme, l’agent mobile a besoin d’un code pour pouvoir s’exécuter. Quand il se déplace à travers le réseau, l’agent peut soit emporter son code soit aller à destination, voir quel code est disponible sur la machine distante et récupérer le code manquant à partir du réseau. L’implémentation d’agent doit être à la fois exécutable et sans risque pour l’hôte de destination. 41

Chapitre 3

Le concept Agent

c. L’interface : un agent fournit une interface qui permet aux autres agents et aux autres systèmes d’interagir avec lui. Cette interface peut être un ensemble de méthodes qui permet aux autres agents et applications d’accéder aux méthodes de l’agent par un système de messagerie. d. L’autorité : une autorité est une entité dont l’identité peut être authentifiée par n’importe quel système auquel elle essaye d’accéder. Une autorité peut être soit une personne privée, soit une organisation. L’identité est constituée d’un nom et d’autres attributs. Pour les agents, il existe principalement deux types d’autorités : Le fabriquant (manufacturer) qui est le fournisseur du code d’implémentation de l’agent, Le propriétaire (owner) qui a la responsabilité du comportement de l’agent. e. L’identifiant : Chaque agent possède un identifiant unique durant son cycle de vie, qui lui permet d’être identifié et localisé et qui soit géré par un service de nommage. Le nom de l’agent est une combinaison de son autorité, de l’identifiant d’une instance particulière de l’agent et de l’identifiant de type du système d’agent dans lequel il évolue. Ce nom est immuable avec les déplacements de l’agent. L’identifiant permet également au système de destination de savoir s’il est capable d’interpréter l’agent entrant.

5.1.3 Caractéristiques d’un agent mobile Les principales caractéristiques sont [MEN, 04]: 1. La mobilité : est la première caractéristique d’un agent mobile, ça concerne les mécanismes utilisés pour transporter l’agent entre les différents sites, c'est-à-dire que le déplacement de l’agent soit contrôlé par la fonction de migration. Deux types de migration existent ; la migration faible et la migration forte : Migration faible : transfert du code et de données ; Migration forte : transfert du code, de données et de l’état d’exécution. 2. La communication : un modèle de communication est nécessaire dans un système d’agents mobiles : ils peuvent communiquer sur le même site (communication locale), ou sur des sites différents (communication à distance). 3. La gestion des ressources : lorsqu’un agent mobile se déplace sur un site, il y utilise des ressources, tant matérielles (cycles CPU, segments mémoire, accès disque, accès réseau) que logicielles (bases de données, fichiers, programmes, interface utilisateur). Il est donc impératif que ces ressources soient contrôlées par leurs prioritaires, qu’ils doivent éviter que l’agent mobile monopolise certaines de ces ressources. L’agent a aussi besoin de contrôler ses propres ressources afin d’optimiser leurs performances et satisfaire aux exigences des hôtes. 4. La tolérance aux pannes : comme un agent mobile s’exécute sur un site distant, il pourra tomber en panne (déconnexion, défaillance…). Il faut donc définir des 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.1.4 Types d’agents mobiles Plusieurs types d’agent mobiles peuvent exister. Ces derniers sont à regrouper en fonction des tâches génériques qu’ils sont en mesure d’exécuter [ROU, 04]. Agent statique : Un agent statique est un agent mobile qui ne fait en général qu’une seule migration, cette migration s’effectue depuis la station de départ vers un nœud bien définit au lancement. A l’arrivée sur le nœud, l’agent mobile ne migre plus mais exécute une tache prédéfinie. Agent visiteur : C’est un agent mobiles qui visite successivement les différents nœuds de la plateforme afin d’y appliquer la même fonction d’administration du réseau, par exemple, récupérer les versions des systèmes d’exploitation installés sur les nœuds du réseau. Agent collecteur de données : Un agent collectant les données est un agent mobile qui nécessite un point de rendezvous avec un ou plusieurs agents mobiles pour les décharger des données que ces derniers ont collectées. Cette agent de collecte peut toutefois récupérer des données qui ont étés laissées à sa disposition sur les différents systèmes par d’autres agents mobiles, après la collecte cet agent transporte les données jusqu'à un système définit à l’avance. Agent transporteur : C’est un agent qui transporte des agents mobiles d’un réseau à un autre, ou qui transporte les agents mobiles dans un sous réseau du même système. Il permet d’éviter la multiplication des procédures d’authentification des agents mobiles lors du passage d’un réseau à un autre (Par exemple si les contraintes imposées aux agents mobiles sont différentes). Agent de suivi d’incident : C’est un agent qui est programmé pour réagir aux données qu’il analyse. 43

Chapitre 3

Le concept Agent

5.1.5 Avantages des agents mobiles Le paradigme des agents mobiles est prometteur, mais les agents mobiles ne parviennent pas à s’imposer comme technologie viable. Certains se demandent même s’ils sont utiles. Pourtant les agents mobiles apportent des bénéfices et il est utile de les utiliser dans certains cas. Plus précisément, il existe sept bonnes raisons d’utiliser les agents mobiles : 1. Réduction du trafic réseau: Les systèmes distribués basés sur le paradigme Client–Server génèrent de multiples interactions entre le client et le serveur, le paradigme des agents mobiles permet d’empaqueter un dialogue et de l’envoyer sur le site distant ou les interactions (multiples) se feront en local. Plus le volume d’informations stockées sur les sites est important, plus l’approche agent mobile est forte : déplacer les traitements vers les données plutôt que déplacer les données vers les traitements. 2. Suppression de la latence du réseau : Pour les applications critiques qui nécessitent du temps réel, il est impératif de supprimer la latence du réseau (temps mort du au temps nécessaire pour se connecter). Les interactions locales offertes par les agents mobiles résolvent ce problème. 3. Encapsulation des protocoles : Lorsque les hôtes d’un réseau utilisent des protocoles différents les uns des autres, un agent mobile peut encapsuler le protocole nécessaire pour s’exécuter sur un site donné. 4. Exécution asynchrone et autonome : Les agents mobiles s’exécutent de manière autonome et comportent une caractéristique essentielle ; L’asynchronisme. Cela permettra d’envoyer un agent mobile sur le réseau puis de se déconnecter. Une fois terminée sa tache, l’agent notifie au site initiateur qui se reconnecte pour récupérer les résultats. Une fois le client reconnecté, il pourra récupérer ses agents mobiles qui auront terminé leurs taches. 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.

5.2 Paradigme d’agent mobile Pourquoi utiliser des agents mobiles ? Pour répondre à cette question qui a du mal à trouver une réponse définitive, nous allons présenter des schémas d’organisation distribuée afin de montrer la différence entre ses schémas et ce paradigme.

5.2.1 Schéma d’organisation Client/Serveur Le client-serveur constitue le schéma d’organisation distribué le plus populaire et le plus répandu jusqu’à présent, c’est le modèle de base pour le développent des applications réparties. Dans ce schéma, on distingue deux entités : le fournisseur du service (ou serveur) et le consommateur du service (ou client) [MEN, 04]; Le serveur : celui qui répond aux besoins du client ; il héberge un certain nombre de services qui fournissent des accès à des ressources comme l’utilisation du CPU (ressource physique), ou l’interrogation d’une base de données (ressource logicielle). Nous disons que le serveur dispose du savoir-faire (know-how), puisque il stocke localement le code qui implémente ces services. Le serveur exécute le service demandé par le client, il a donc la capacité de traitement. Le client : celui qui exprime des besoins ; si un client est intéressé par des ressources hébergées sur un serveur, il utilisera simplement les services fournis à cet effet. Le client doit disposer d’une certaine intelligence pour décider quel service il doit choisir. La figure 16 est une simple présentation de ce schéma :

Serveur

Clients

Figure 16: Le schéma client/serveur.

45

Chapitre 3

Le concept Agent

Nous pouvons dire que le client-serveur est une technique de dialogue entre deux processus, un processus client et un processus serveur. En effet, seul le client, demandeur du service, est à la base du dialogue, ça veut dire que c’est lui qui l’initie. De son coté, le serveur ne fait que répondre aux requêtes des clients. Une requête est un message qui décrit l’opération à exécuter (le service) ainsi que ses données paramètres [ROU, 02]. Ce schéma est dit synchrone : le client émet une requête et se bloque jusqu’à l’arrivée de la réponse. Afin de satisfaire un client en accomplissant un service pour son compte, trois éléments doivent se trouver dans le même site à un instant donné. Ils sont nécessaires pour l’exécution d’un service [ROU, 02]: 1. Le code du service (savoir-faire) ; 2. L’unité d’exécution ou « processeur » qui est une machine qui encapsule l’état d’exécution, par exemple : pile d’exécution, compteur ordinal… ; 3. Un ensemble de ressources qui représentent les données passives ou les unités physiques, par exemple : base de données, fichiers, mémoire, processeur, etc. Ce fonctionnement est simplifié à travers la figure suivante :

Figure 17: Le fonctionnement du schéma client/serveur.

5.2.2 Autres schémas d’organisation avec mobilité En marge du schéma client/serveur, il existe d’autres schémas qui utilisent la mobilité du code exécutable pour répartir les tâches d’exécution. Voici les principaux schémas [ROU, 02] :

5.1.2.1 Evaluation distante Dans une interaction par évaluation distante (Remote Evaluation ou REV), un composant client envoie un code à un autre site. Le composant récepteur exécute le code, qui peut contenir des données, et renvoie les résultats au composant émetteur. 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’interaction par évaluation distante est illustrée dans la figure suivante :

Figure 18: Le schéma Evaluation distante.

Des exemples d’évaluation distance sont : -

La commande rsh du système Unix, qui permet à un utilisateur d’exécuter une suite d’instructions (ou script) sur un site Unix distant. Les interactions avec les imprimantes ‘’PostScript’’ utilisent le schéma REV. Les requêtes SQL (Structured Query Language) émises vers un serveur de base de données. Les servlets Java présentes sur un serveur HTTP.

5.1.2.2 Code à la demande Dans le schéma de code à la demande (Code On Demand ou COD), le composant client interagit avec le composant serveur afin de récupérer le code nécessaire à la réalisation d’un service. La requête sur le site serveur ne contient pas de données paramètres, le composant serveur fournit le code du service qui sera exécuté sur le site client. En permettant à des composants de récupérer du code, ce schéma permet d’étendre dynamiquement le comportement d’une application. Ainsi, la figure 19 montre le schéma Code à la demande :

Figure 19: Le schéma Code à la demande.

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 :

Figure 20: Le schéma Agent mobile.

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.

5.2.3 Fonctionnement des agents mobiles Les agents mobiles supportent les opérations déconnectes grâce au mode d’interaction asynchrone. Ils sont indépendants des sites clients qui peuvent se déconnecter et se reconnecter afin de récupérer ultérieurement l’agent et ses résultats. Le paradigme d’agents mobiles propose d’utiliser la migration du code afin de supprimer la contrainte de connexion constante. On demande aux deux parties d’être connectées seulement pendant la phase de migration. Ainsi un agent mobile peut se déplacer dans un réseau de machines offrant des services pour réaliser une tache complexe. Un client donne une mission à un agent qui pour la réaliser se déplace dans le réseau de machines accédant localement aux services offerts par ces machines, on peut distinguer trois phases : L’activation de l’agent mobile avec la description de sa mission. L’exécution de la mission par l’agent qui se déplace pour accéder aux services. La récupération éventuelle des résultats de l’agent mobile.

48

Chapitre 3

Le concept Agent

La figure suivante (Figure 21) présente le paradigme d’agent mobile :

Figure 21: Paradigme d’agents mobiles.

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.

3 Vision proposée: Vers une supervision à base d’agents mobiles Avant d’entamer la conception de notre plate forme de supervision, nous allons d’abord discuter les diverses situations possibles pour répondre à la problématique. Comme nous l’avons vu dans le chapitre 2, il existe plusieurs méthodes de détection, ce qui induit qu’en faisant varier la méthode de détection et le nombre d’agents en interaction, nous obtiendrons plusieurs cas de figure ou scénario. Dans ce qui suit, nous allons les présenter tout en donnant leurs principaux avantages et inconvénients.

3.1 Utilisation d’un seul agent mobile pour la supervision Dans ce cas, on utilise un agent mobile qui va migrer vers chaque machine supervisée, pour y effectuer des tests sur les services considérés, la résolution des problèmes relevés est basée sur une base de règles (base de connaissance de l’agent) pouvant être étendue et personnalisée par l’utilisateur. L’agent envoie des rapports périodiques au site de supervision pour informer l’administrateur du déroulement des opérations. Avantages: • Economise la consommation de la bande passante. •

Nœud central peu sollicité.

Inconvénients : • Difficulté d’implémentation vu le manque de modularité.

La figure suivante (Figure 22) illustre les différentes étapes de ce cas de figure. 52

Chapitre 4

La Conception

Figure 22: Utilisation d’un seul agent mobile pour la supervision.

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. c) Quelque soit le résultat des tests, diagnostiques ou réparations, l’agent remonte un message au serveur contenant un rapport détaillé. 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.

3.2 Utilisation d’un agent pour la détection et un autre pour la réparation Dans ce cas, deux agents sont employés, le premier sera dédié aux tests des différents aspects supervisés, et l’autre intervient seulement dans le cas d’anomalies ou il doit réagir suivant sa base de règles qui seront toutefois personnalisée par l’utilisateur en fonction de ses besoins et exigences. •

Avantages : Simplicité d’implémentation et modularité des programmes.

•

Taille des agents moins importante.

La figure suivante (Figure 23) illustre les différentes étapes de ce cas de figure. 53

Chapitre 4

La Conception

Figure 23 : Utilisation d’un agent pour la détection et un autre pour la réparation.

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. d) Exécution de l’agent réparateur, et envoie du rapport final contenant les résultats obtenus. 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.

3.3 Détection avec NAGIOS et réparation par agent mobile Cette solution se base sur les résultats des tests effectués par Nagions puisqu’ il se restreint à la détection ; on complétera alors le manque de ce dernier en ajoutant les parties : diagnostique et résolution des pannes implémentés dans un agent mobile qui se mobilise à l’apparition d’anomalies.

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.

Figure 24: Détection avec NAGIOS et réparation par agent mobile.

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. d) Retour de l’agent ou envoi de son rapport d’exécution au serveur d’application.

Voie choisie : Le deuxième scénario Dans le but d’atteindre notre objectif, nous avons opté pour le deuxième scenario ou deux types d’agents sont utilisés ; des agents pour les tests et des agents de réaction, ce 55

Chapitre 4

La Conception

choix est dû en grande partie à la modularité offerte par cette solution par rapport aux autres solutions.

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.

Conception du SMA selon la méthodologie « Voyelle » La méthodologie Voyelles comporte trois étapes essentielles :

La phase d’Analyse ou d’Identification des composantes.

La phase de conception ou de Choix des modèles fonctionnels.

La phase de programmation ou d’implémentation.

Nous ne suivrons, dans cette partie de conception, que les deux premières phases. La dernière étant relative à l’implémentation des agents (phase de réalisation). Phase1 : Analyse Consiste à identifier à priori les quatre composantes : A, I, E, O et U (respectivement, Agent, Interaction, Environnement, Organisation et Utilisateur). Phase2 : Conception Cette phase consiste à choisir les modèles fonctionnels des composantes préalablement définies.

4.1 Phase 1 : Analyse L’analyse se base sur :

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 : •

Interactions entre l’administrateur et l’agent de gestion : Elles correspondent soit à l’action de l’acteur sur les paramètres du système (interaction utilisateur-agent), soit à la présentation d’informations et de résultats dans une interface graphique (interaction agent-utilisateur).

•

Interactions entre les Agents. Elles correspondent à l’envoi et à la réception des messages, tels que les requêtes de migration, les messages des résultats de collecte de données ou les rapports d’exécution des agents.

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 ; • •

•

un agent administrateur s’occupe de la coordination entre les différentes entités du système ; des agents de test migrent vers tous les sites qui doivent être supervisés, et envoient régulièrement des rapports des résultats obtenus après analyse de leurs nœuds respectifs aux agents de réaction ; les agents de réaction intégrant des méthodes SNMP agissent suivant ces données, pour soit tenter de régler les anomalies éventuelles, ou avertir l’utilisateur le cas échéant.

Le schéma suivant résume d’une manière concise le principe de déroulement des diverses taches de supervision (Figure 25).

Figure 25: Schéma général du système.

Agent de gestion : C’est le cerveau du system, il est stationnaire et a pour principal rôle la coordination et la synchronisation entre les agents du système, il est instancié avant les deux autres types d’agent et sa durée de vie est équivalente à celle du système 58

Chapitre 4

La Conception

Agents d’analyse : Ce sont des agents collecteurs de données via SNMP, ils se déplacent sur le réseau et rassemblent les données relatives aux nœuds du système, ces données sont redirigées vers l’agent de gestion qui les analyse et décide de l’action à entreprendre. 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.

4.2.2 Principe de fonctionnement : Le principe du déroulement de la supervision est illustré par le schéma suivant (Figure 25):

Figure 26: Principe de fonctionnement.

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. 3. L’agent d’analyse récolte les informations localement et envoie des rapports périodiques à l’agent de gestion. 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. 5. L’agent de réactions s’exécute localement et tente de rétablir le fonctionnement normal de chaque service présentant des problèmes. L’agent de réaction envoie ensuite un rapport d’exécution à l’agent de gestion lui indiquant si l’opération s’est bien déroulée ou si le problème persiste, il s’autodétruit juste après vu que sa tache est à présent terminée. N.B : Le fonctionnement normal de la supervision repose sur la disponibilité de la connexion, ainsi, pour vérifier à chaque instant que les sites supervisés sont toujours connectés au centre de supervision, des modules spécifiques s’occupent d’envoyer des requêtes PING périodiquement aux différents nœuds du réseau. S’ils ne reçoivent pas de requêtes PING après un délai déterminé, l’administrateur est alerté d’une défaillance de communication qui pourrait être due à différentes causes (câble réseau débranché, default d’adresse IP, Pare-feu bloquant la communication, …etc.).

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 :

Figure 27 : Entités et composantes du système.

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 C’est le cerveau du système, il pilote l’application et gère l’intégralité de l’opération de supervision, il reçoit en entrée des données et des paramètres pouvant provenir des autres agents tels que les rapports d’analyses ou les rapports d’exécution des agents de réaction, et des informations sur l’environnement et la méthodes de supervision tels que la connexion ou la déconnexion d’un nœud, les problèmes de communication, le changement de paramètres et des préréglages par l’administrateur. Différents modules sont implémentés dans le corps de cet agent : •

Des modules d’émission et de réception de messages entre agents, elle est globalement la même sur tous les agents.

•

Des modules et routines de gestion et de traitement des donnés d’analyses et de gestion de l’application.

•

Des modules de test de disponibilité de connexion avec les nœuds supervisés du réseau.

Le schéma suivant illustre mieux l’architecture interne de cet agent (Figure 28):

Figure 28 : Agent de gestion.

62

Chapitre 4

La Conception

Agent d’analyse Il est moins complexe que l’agent de gestion, il comprend une unité de communication, et des modules pour accomplir la tache de collecte d’information sur l’état les services du nœud ou il se trouve. Principalement c’est des routines SNMP. Il reçoit en entrée des données de commandes telles que les requêtes de migration vers des nouveaux nœuds, ou les changements éventuels de paramètres de supervision. Le schéma suivant illustre mieux l’architecture interne de cet agent (Figure 29):

Figure 29 : 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 :

Figure 30 : Agent de réaction.

4.3.5 Schéma d’interaction Inter-Agents La communication et échange de données dans les SMA se fait soit par mémoire partagée ou par messages, mais du moment ou le système comprend des agents mobiles, la première méthode devient difficile à gérer et augmente le trafic sur le réseau, pour cela nous avons opté pour la communication par messages afin de nous simplifier les travail, chaque agent comme décrit précédemment contient des modules de gestion de communication inter-agents, les messages sont au format texte, formatés d’une manière à simplifier leur découpage pour extraire et interpréter leurs contenu. Un protocole de communication spécifique est utilisé pour assurer l’échange de messages inter agents. Le schéma suivant résume la communication entre les agents du système (Figure 31):

Figure 31: Schéma d’interaction inter-agents.

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).

Le schéma UML suivant illustre la chronologie des interactions inter-agent :

Figure 32: Diagramme d’interaction inter-agents

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.

Nous allons présenter dans le chapitre qui suit l’implémentation et la réalisation de l’architecture proposée.

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):

Figure 33: Environnement de développement.

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. -

2.1 Plateforme JADE pour le développement des SMA Pour développer des agents, il est pratique de choisir une plate-forme. A l’heure actuelle, plusieurs outils ont été développés pour la réalisation d’agents. Si ces plateformes abondent en quantité, elles ne répondent pas toutes aux critères que nous nous sommes fixés. Cette partie présente notre démarche dans le choix d’une plate forme de développement d’agents. La plate forme devra répondre aux contraintes suivantes : -

-

La plate forme doit répondre à plusieurs fonctionnalités et offrir une large gamme de bibliothèques. Il faut tenir compte de la nature de l’interface de développement vu le temps court réserver au développement des agents. La plateforme doit être répandue. Elle doit avoir été utilisée dans plusieurs projets de développement de systèmes multi-agents pour avoir un maximum d’exemple et de tutoriaux. Le langage de programmation sous jacent et la nature des messages échangés sont aussi un point important. Un langage connu et répandu favorisera une meilleure compréhension des codes sources.

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.).

JADE est une plate-forme multi-agents développée intégralement en JAVA, par F. ellifemine & A. Poggy, G.Rimassa, P. Turci pour la société de télécommunications CSELT (Italie) en 1999. Elle a pour but de faciliter le développement des applications agent conformément à la norme FIPA (Fondation for Intelligent Physical Agents) pour les systèmes multi-agents interopérable. JADE essaye d’optimiser les performances d’un système d’agents distribué. (Une description détaillée de JADE est donnée dans l’annexe).

2.2 Environnement Eclipse pour programmer en JAVA JAVA fut le langage de notre choix vu que nous avons choisi préalablement la plateforme JADE, et aussi grâce à sa portabilité et à son aspect Orienté Objet qui facilite la migration d’une conception d’objet vers une implémentation de classe. Pour Eclipse, c’est un environnement de développement intégré (le terme Eclipse désigne également le projet correspondant, lancé par IBM) extensible, universel et polyvalent, permettant potentiellement de créer des projets de développement mettant en œuvre n'importe quel langage de programmation. Eclipse est principalement écrit en Java, et ce langage, grâce à des bibliothèques spécifiques, est également utilisé pour écrire des extensions. La spécificité d'Eclipse vient du fait de son architecture totalement développée autour de la notion de plug-in: toutes les fonctionnalités de cet atelier logiciel sont développées en tant que plug-in. Plusieurs logiciels commerciaux sont basés sur ce logiciel libre.

2.3 Le package ‘’SNMP4J’’ pour les tests des services SNMP4J est un package pour java permettant d’intégrer les fonctions et des routines SNMP dans des programmes java, pour notre cas d’utilisation, ce sera l’outil élémentaire pour implémenter les corps des agents d’analyse et de réaction pour manipuler des services systèmes en plus des commandes de l’API de Windows (Application Programming Interface : ensembles de commandes et fonctions de gestion du système d’exploitation). Il intègre aussi les agents SNMP qui vont être lances dans les machines supervisées afin d’en récolter et de récupérer les données nécessaires.

3 Intégration de JADE et SNMP4J dans Eclipse L’intégration de JADE est SNMP est simple a faire sur Eclipse, il suffit de définir pour un projet les différentes bibliothèques utilisées. 69

Chapitre 5

L’implémentation

La figure suivante (Figure 34) montre l’explorateur de package après intégration des JARs.

Figure 34: Intégration de JADE et SNMP4J avec Eclipse.

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).

Figure 35: Le moniteur JADE RMA.

4 Présentation de l’interface de MAMS (Multi Agent Monitoring System) L’environnement de l’application est intuitif et très simple d’usage, il permet d’avoir une vue globale sur le fonctionnement des services considérés sur les nœuds supervisés. Aussi mous avons pensé à un champ LOG (Journal) pour lister a chaque étape l’état du système. Pour chaque machine supervisée on utilise une sorte de tableau de bord qu’on affiche pour donner en tout instant l’état actuel de la machine et des services supervisés sur celle-ci. La figure suivante représente l‘interface utilisateur après démarrage de MAMS (Figure 36).

71

Chapitre 5

L’implémentation

Figure 36: L’interface utilisateur MAMS.

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

Figure 37 : Le client de supervision.

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. 2. 3. 4.

Le HyperText Transfer Protocol, plus connu sous l'abréviation HTTP. Le service DHCP pour : Dynamic Host Configuration Protocol. Le service d’accès au web à travers le réseau : WebClient. 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

Figure 38: Les services supervisés.

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.

Figure 39: Les 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. L'approche d'agents mobiles constitue un paradigme de programmation puissant et efficace pour les applications sur réseau. La réalisation de ce projet nous a permis de mettre en pratique nos connaissances théoriques. Nous nous sommes entre autres familiarisés avec les outils suivants : L’environnement Eclipse pour développement d’applications Java. La plateforme multi agents « Jade » pour l'implémentation des SMA. L’approche SNMP pour la supervision sur réseaux. Et bien sur, il y a toujours place pour l’amélioration de notre architecture, comme perspectives nous pouvons penser à : -

-

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

[BRA, 87]

M. E. BRATMAN, « Intention, Plans, and Practical Reason ». Harvard University Press: Cambridge, MA - 1987.

[BUF, 03]

O. BUFFET, « Une double approche modulaire de l’apprentissage par renforcement pour des agents intelligents adaptifs », Université Henri Poincaré – Nancy France, 2003.

[CHA, 94]

B. CHAIB-DRAA, « Distributed Artificial Intelligence: An overview », Encyclopaedia of Computer Science and Technology, volume 31, pages 215-243, 1994.

[CHA, 01]

B. CHAIB-DRAA, I. JARRAS et B. MOULIN, « Systèmes multi-agents : Principes généraux et applications », Article paru dans : J. P. BRIOT et Y. DEMAZEAU « Agent et systèmes multi-agents » chez Hermès , 2001.

[CHE, 02]

V. CHEVRIER, « Contributions au domaine des systèmes multi-agents », Mémoire d’habilitation à diriger des recherches. Université Herni Poincaré, Nancy, 2002.

[COU, 07]

R. COURDIER, « Cours Intelligence Collective et Système Multi-Agents ». Université de la Réunion, 2007

[DEM, 95]

Y. DEMAZEAU, « From Interactions to Collective Behaviour in AgentBased Systems », Proceeding of the First European Conference on Cognitive Science, Saint-Malo, p. 117-132, 1995.

[DEM, 01]

Y. DEMAZEAU et J.P. BRIOT, « Introduction aux agents: Principes et architecture des systèmes multi agent », collection IC2, Hermès, 2001.

[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.

[DRO, 05]

A. DROGOUL, MIRIAD, « Systèmes multi-agents », OASIS/LIP6, Université Paris 6.

[DUR, 89]

E. H. DURFEE, V. LESSER, « Negotiating task decomposition and allocation using partiel global planning », Pitman publishing: London 77

Bibliographie and Morgan Kaufmann: San Mateo, CA - 1989 [FER, 97]

J. FERBER, « Les Systèmes Multi-Agents : Vers une Intelligence Collective », Inter-éditions - 1997.

[GAR, 00]

T. GHARBI, « Structuration d’applications environnement mobile », USTHB, 2000.

[GUE, 96]

Z. GUESSOUM, « Un environnement opérationnel de conception et de réalisation de systèmes multi – agents ». Thèse de l’université de paris6 Laforia, 1996.

[HOA, 02]

T. HOANG et M. KOLP, « Développement de patrons de conception à ancrage social pour architectures multi-agents ». Belgique, 2002.

[KLU, 99]

M. KLUSCH, « Intelligent Information agents: Agent-based information discovery and management on the internet », Springer preface, 1998.

[LAB, 93]

S.LABIDI, W.LEDJOUAD, « De l’intelligence artificielle distribuée aux systèmes multi-agents », Institut national de recherche en informatique et automatique INRIA France, Août 1993.

[LAR, 03]

B. LARAB et A. ZERHOUNI, « Agents mobiles anonymes », USTHB Alger, 2003.

[LUD, 99]

L. BLIN, « Gestion des télécommunications, de la télématique et de la télévision », Septembre 1999.

[MAE, 95]

P. Maes, « Artificial Intelligence meets Entertainment: Lifelike Autonomous Agents », Communications of the ACM 38 (11), pp. 108114, novembre. 1995.

[MAL, 94]

T. MALONE et K. CROWSTON, « The interdisciplinary study of coordination », ACM Computers Surveys, 1994

[MBA, 03]

A. MBALA HIKOLO, « Analyse, conception, spécification et développement d’un système multi-agents pour le soutien des activités en formation à distance », octobre 2003.

[MED, 07]

S. MEDJADBA et H. BOULEFAAT, « Conception et réalisation d’un comparateur des prix à base des agents mobiles », USTHB Alger, 2007

[MEL, 04]

T. MELLITI, « Interopérabilité des services Web complexes. Application aux systèmes multi-agents », décembre 2004.

[MEN, 04]

D.E. MENACER, « Un modèle d’architecture à base d’agents mobiles pour les applications réparties », Institut national de formation en informatique Alger, 2004.

réparties

dans

un

78

Bibliographie [NWA, 96]

H. S. Nwana. « Software Agents Knowledge Engineering: An Overview ». 1996.

[OLI, 98]

R. F. Teixeira De OLIVEIRA, « Gestion des Réseaux avec Connaissance des Besoins: Utilisation des Agents Logiciels », Thèse de l’ENST de Paris, 1998.

[OUD, 05]

Clément OUDOT, « Linagora : Utilisation du module Rapport de Nagios », 2005.

[PER, 97]

P. Stéphane, « Agents mobiles pour l’accès nomade à l’information répartie dans les réseaux de grande envergure », Université Joseph Fourier - Grenoble, 1997.

[PIC, 04]

G. PICARD, « Méthodologie de développement de systèmes Multi agents adaptatifs et conception de logiciels à fonctionnalité émergente », Université Paul Sabatier de Toulouse III, 2004.

[REU, 04]

E. REUTER, « Agents Mobiles : Itinéraires pour l’administration système et réseau », Université de Nice Sophia Antipolis, Mai 2004.

[RIC, 01]

P.M. RICORDEL, « Programmation Orientée Multi-Agents », Institut national polytechnique de Grenoble, octobre 2001.

[ROU, 04]

L. ROUANE, « L’apport des systèmes multi-agents à la recherche d‘information dans les bases de données réparties », Institut national de formation en informatique d’Alger, 2004

[SAB, 01]

A. SABAS, « Systèmes multi-agents : une analyse comparative des méthodologies de développement », Université du Québec à TroisRivières, Octobre 2001.

[SEC, 03]

Y. SECQ, « RIO : Rôles, Interactions et Organisations une méthodologie pour les systèmes multi-agents ouverts », Université des Sciences et Technologies de Lille France, 2003.

[SEK, 07]

L. SEKHRI et N. KADRI, « Une approche multi-agent pour la détection d’intrusions », Institut national de formation en informatique d’Alger, 2007.

[WHI, 95]

J.E. WHITE, « Telescript technology : an introduction to the language », General Magic Inc., 1995

[WOO, 95]

M. Wooldridge, « N. R. Jennings, Agents: Theory and Practice », 10(2): 115-152, 1995.

[WOO, 02]

M. WOOLDRIDGE, « An introduction to Multiagent Systems », John Wiley and Sons Publishers – Angleterre, 2002. 79

Web-graphie [Lien 1]

« Modèle Agent-Cellule, un Agent réactif »,

[Lien 2]

P.E. MICHON, D. DUGUAY et G. EDWARD, « Modules d’un agent cognitif »,

[Lien 3]

E. D’HEM, « La sécurité par le monitoring 2003 »,

[Lien 4]

«Annuaire des logiciels libres»,

[Lien 5]

D. REVUZ, « Nagios et la Supervision » http://www-igm.univ-mlv.fr/~dr/XPOSE2004/nchaveron/Supervision.html#modules

[Lien 6]

N. CHAVERON, « La supervision de Nagios », , Décembre 2004

[Lien 7]

L. DESIMONE, P. JERMINI, « Le monitoring avec Nagios », , Mars 2008

[Lien 8]

A. M. FLOREA, « Agents intelligents », < http://turing.cs.pub.ro/auf2/>, 2002.

[Lien 9]

« Management Information Base »,

[Lien 10]

C. CALECA, « Tutoriel SNMP », , Septembre 2003

[Lien 11]

S. CALON, S. FONTAINE, « Cours SNMP », , Septembre 2007

[Lien 12]

Hewlett Packard, « OpenView User Guide 2004 », < http://www.hp.com>, 2004

[Lien 13]

IBM Tivoli Monitoring, « Guide de l’utilisation Version 5.1.2 », < http://www.IBM.com>

[Lien 14]

E. GALSTAD, « Nagios Version 3.x Documentation », , 2007

[Lien 15]

G. BERNARD, « Etude Nagios », < http://www.todoo.biz/>, 2003

80

Annexe : La plate-forme JADE

Annexe : La plate-forme JADE 1 - Présentation de la plate forme JADE Le meilleur moyen pour construire un Système Multi-Agent (SMA) est d'utiliser une plate-forme multi-agent. Celle-ci est un ensemble d'outils nécessaire à la construction et à la mise en service d'agents au sein d'un environnement spécifique. Ces outils peuvent servir également à l'analyse et au test du SMA ainsi créé, ils peuvent être sous la forme d'environnement de programmation (API7) ou d'applications permettant d'aider le développeur à la programmation d’un SMA ainsi que son débogage. 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 -

Un environnement d’exécution (Runtime environnement) où les agents JADE vivent ;

7

Application Programming Interface. 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 8

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.

1.2 - Conteneurs et Plateformes Chaque instance de l'environnement d'exécution de JADE est appelée « conteneur » (container) car elle peut contenir plusieurs agents. L'ensemble des conteneurs actifs est appelé « plateforme ». Dans chaque plateforme, un conteneur spécial appelé conteneur principal (main container) doit toujours être en activité, les autres conteneurs s'enregistrent auprès de celui-ci à leur démarrage. 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).

Figure 1. Conteneurs et plateformes.

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. Chaque JVM est un conteneur d'agents qui fournit un environnement d’exécution complet pour l'exécution d'agents et permet à plusieurs agents de s'exécuter en parallèle sur le même serveur. Chaque conteneur d'agents est un environnement multi- threads composé d'un thread d'exécution pour chaque agent. La distribution de ces conteneurs à travers un réseau d'ordinateurs est permise à condition que la communication RMI10 entre leurs hôtes soit conservée. Chaque conteneur d'agents est un objet serveur RMI qui gère localement un ensemble d'agents. Il règle le cycle de vie des agents (création, suspension, attente et destruction). Il assure en plus, le traitement de tous les aspects de la communication : répartition des messages ACL reçus, routage des messages selon l’agent destinataire (receiver) et dépôt des messages dans les files de messages privées des agents. Pour les messages vers l'extérieur, le conteneur d'agents maintient assez d'information pour chercher l'emplacement de l'agent récepteur et pour choisir une méthode de transport convenable pour expédier le message ACL. La plate-forme offre une interface graphique utilisateur (GUI) pour la gestion à distance qui permet de contrôler et surveiller le statut des agents, par exemple arrêter et remettre en marche un agent. L'interface graphique permet aussi de créer et de commencer l'exécution d'un agent sur un hôte éloigné, à condition qu'un conteneur d'agents s'exécute déjà sur cet hôte. L'interface elle-même a été implémentée comme un agent, appelé RMA (Remote Monitoring Agent). Toute la communication entre les agents et l'interface (GUI) et toute la communication entre cette interface et l'AMS est faite par ACL via une extension ad hoc de l'ontologie des agents de gestion FIPA. JADE supporte la gestion des comportements coopératifs. Le runtime inclut quelques fonctions complexes prêtes à l'emploi pour les tâches les plus communes dans la programmation agent, comme des protocoles d'interaction de FIPA. JADE offre entre

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.

1.3 - La Bibliothèque JADE JADE est composé des principaux packages suivants : -

Jade.core implante le noyau du système. Il possède la classe « Agent » qui doit être étendue par les applications des programmeurs. Une classe behaviour (comportement) est contenue dans jade.core.behaviours, qui est une sous classe de jade.core. Les comportements implémentent les tâches ou intentions des agents.

-

Le package jade.lang contient un sous-package pour chaque langage de communication utilisé par JADE en particulier jade.lang.acl.

-

Jade.content contient un ensemble de classes qui permettent de définir des ontologies.

-

Jade.domain contient toutes les classes Java qui représentent les entités Agent Managment définies par FIPA en particulier AMS et DF.

-

Jade.gui contient un ensemble générique de classes utiles pour la création de GUIs pour l’affichage, l’édition des messages ACL, et de la description des agents.

-

Jade.mtp contient une interface Java que chaque MTP (Message Transport Protocol) doit implémenter.

-

Jade.proto contient des classes qui modélisent les protocoles standards d’interaction. Les classes permettent aussi aux programmeurs d’ajouter d’autres protocoles.

-

JADE est accompagnée de certains outils qui facilitent l’administration de la plate forme et le développement d’applications. Chacun de ces outils est contenu dans un sous package de jade.tools.

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. 1. Remote Managment Agent « RMA » : le RMA permet de contrôler le cycle de vie de la plate-forme et tous les agents la composant. L'architecture répartie de JADE permet le contrôle à distance d'une autre plate-forme. Un RMA est un objet Java, instance de la classe jade.tools.rma.rma et peut être lancé à partir de la ligne de commande Java jade.Boot -gui. Plusieurs RMA peuvent être lancés sur la même plate-forme du moment qu'ils ont des noms distincts.

Figure 2. Interface graphique d’un RMA.

2. Agent Management System « AMS » (système de gestion d’agents) : est un agent qui exerce la supervision et le contrôle de sur l’accès et l’usage de la plateforme (voir figure 2). Il fournit les services de pages blanches en maintenant un répertoire 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.

Figure 3. Interface du DF.

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.

Figure 4. Interface graphique d’un Dummy Agent.

6. Sniffer Agent « SA » : Quand un utilisateur décide d'épier un agent ou un groupe d'agents, il utilise un agent Sniffer. Chaque message partant ou allant vers ce groupe est capté et affiché sur l'interface du sniffer. L'utilisateur peut voir et enregistrer tous les messages, pour éventuellement les analyser plus tard. L'agent peut être lancé du menu du RMA ou de la ligne de commande suivante Java jade.Boot sniffer : jade.tools.sniffer.sniffer 87


Figure 5. Interface du Sniffer Agent.

7. Introspector Agent : Cet agent permet de gérer et de contrôler le cycle de vie d'un agent s'exécutant et de la file de ses messages envoyés et reçus.

Figure 6. Interface de l’introspector.

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 :

Figure 7. Cycle de vie d’un agent.

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


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.

3 - Les Comportements d’agents (Behaviours) Un Behaviour (comportement) représente une tâche qu’un agent doit effectuer. Chaque Behaviour possède deux méthodes : la méthode action() qui définit les opérations à exécuter par l’agent, et la méthode done() qui renvoie un booléen spécifiant si le Behaviour a terminé et doit être supprimé de la file des Behaviours à exécuter par l’agent. Nous distinguons principalement trois types de Behaviours : 1. Behaviours mono-coup « OneShot behaviours » qui se terminent immédiatement et dont la méthode action() est exécutée seulement une fois. La méthode done() retourne «Vrai». 2. Behaviours cycliques « Cyclic behaviours » qui ne sont jamais terminés et dont la méthode action() exécute les mêmes opérations chaque fois qu’elle est appelée. La méthode done() retourne «Faux». 3. Behaviours génériques « Generic behaviours » qui exécutent différentes opérations dépendamment d’un état ; Ils se terminent quand une certaine condition est vérifiée.

90

Annexe : La plate-forme JADE La figure ci-dessous illustre le scénario d’exécution du thread d’un agent.

Figure 8. Exécution d’un thread d’agent.

4 - Communication entre agents 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é.

Figure 9. Le paradigme JADE de traitement asynchrone de message.

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 L'envoi d’un message consiste à créer un objet ACL-Message et appeler la méthode send() de classe « Agent ». Exemple : Le code suivant correspond à l’envoi d’un message à l’agent « Bibito » dans le but de l’informer qu’ « il fait beau aujourd’hui».

ACLMessage msg = new ACLMessage (ACLMessage.INFORM); msg.addReceiver (new AID ("Bibito", AID.ISLOCALNAME)); 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.

Public void action() { ACLMessage msg = myAgent.receive(); if (msg != null) { // Message reçu : Traitement du message; } else {

93

Rapport Supervision pdf

Recommend Documents