Objectif JMX (Java Management eXtension)

Mise en oeuvre de l'administration avec JMX (Administration et supervision des serveurs JavaEE)
Mise en oeuvre de l'administration avec JMX (Administration et supervision des serveurs JavaEE)
Auteurs: Didier Donsez
•Objectif
•JMX (Java Management eXtension)
•Réalisation
°Installation
°Préliminaires
°Instrumentation simple
·Instrumentation simple d'une application Java application
·Instrumentation simple d'une webapp WAR JavaEE
·Instrumentation simple d'une EAR JavaEE
·Instrumentation simple des serveurs CORBA
°Réalisation du déploiement dynamique des servants (déprécié)
°Réalisation d'un adaptateur pour IIOP
°Réalisation d'un adaptateur RESTFul
°Réalisation d'un plugin dans la JConsole (déprécié)
·pour superviser les serveurs CORBA
°Réalisation d'un plugin dans la VisualVM
·pour superviser le composant EuroConvertor
°Sécurisation de l'administration et du déploiement
°JMX avec ANT
°JMX avec ANT et LDAP
°MEJB
•Documentation
•Bonus track
°Installation et Démarrage de JManage
Page originale: http://www-adele.imag.fr/users/Didier.Donsez/ujf/GICOM/GICOM_ENS/sujet/etape7.html
Objectif
Cette extension consiste à permettre l'administration et la supervision des serveurs JavaEE de l'application
eCOM. Pour cela, vous vous appuierez sur l'API JMX disponible depuis le JDK 5.0.
JMX (Java Management eXtension)
JMX (Java Management eXtension) est un service de supervision et d'administration d'applications Java qui
s'inspire de SNMP qui est le protocole d'administration de nœuds IP. JMX permet de superviser et
d'administrer des ressources matérielles accessibles depuis une JVM comme des ressources logiciels
s'exécutant sur une JVM. L'instrumentation des ressources se fait au moyen de composants appelés
MBean (Manageable Bean). La spécification JMX définit l'ensemble des interfaces et classes nécessaires à
cette instrumentation.
L'interaction avec les MBeans peut suivre le modèle Pull pour lire et changer la configuration des
applications (par exemple, récupérer des statistiques, l'usage des ressources, ...) ou bien suivre le modèle
Push pour notifier des événements (par exemple, signaler des problèmes, des fautes, des changements
d'état, ...).
L'architecture JMX comporte 3 niveaux (voir figure 1) :
• le niveau Instrumentation qui comporte les MBeans,
• le niveau Serveur qui introspecte l'état des MBeans et exécute les opérations sur ces derniers,
• et le niveau Distribution qui permet à des consoles distantes de l'interfacer avec le serveur de MBean.
° Les connecteurs déportent l'interface du serveur
ObjectWeb - Wiki - Main - frjmx
-1-

° tandis que les adaptateurs offrent des interfaces d'autres types (HTML/HTTP, SNMP, IIOP, ...).
Les MBeans exposent une interface d'administration comportant un ensemble d'attributs consultables et/ou
modifiables et un ensemble des opérations invocables. Il existe quatre types de MBean : standard MBeans,
dynamic MBeans, open MBeans et model Mbeans. Un standard MBean a une interface qui est définit
statiquement. Le nom de l'interface implémentée doit être préfixé pour le nom de la classe d'implémentation
et suffixé par "MBean". Un dynamic MBean permet d'exposer dynamiquement ses attributs et ses
opérations. La classe d'implémentation doit implémenter l'interface DynamicMBean. Le JSR 255 simplifie la
programmation des MBeans pour l'utilisation d'annotations pour annoter des POJOs. La liste des
annotations est : @Description, @DescriptorFields, @DescriptorKey, @ManagedAttribute,
@ManagedOperation, @MBean, @MXBean, @NotificationInfo, @NotificationInfos (package
javax.management).
Un MBean peut notifier des changements en implémentant l'interface NotificationBroadcaster.
Un MBean peut récupérer la référence du MBeanServer qui l'enregistre en implémentant l'interface
MBeanRegistration. Les adaptateurs sont généralement des MBeans enregistrés qui implémentent cette
interface.
Les Platform MBeans (appelés MXBeans) qui ont été introduit dans la plateforme Java 5.0, sont des
MBeans instrumentant la JVM : ils décrivent le système de chargement des classes, la compilation JIT, le
ramasse-miette, les loggers, les threads, du système d'exploitation …
Initialement adopté par la communauté J2EE, la spécification JMX fait partie désormais de la Java Platform
depuis la version 5.0. Des implémentations alternatives de JMX sont disponibles pour instrumenter des
applications J2SE antérieure à J2SE 5.0. MX4J http://mx4j.sf.net est l'une d'entre elles. Elle est d'ailleurs
embarquée par JOnAS quand il s'exécute sur des plateformes Java antérieures à 5.0.
Figure 1 : Architecture à 3 niveaux de JMX.
Réalisation
Installation Récupérez les exemples JMX au moyen d'un checkout de la forge eCOM
ObjectWeb - Wiki - Main - frjmx
-2-

La commande est la suivante : svn checkout
svn://svn.forge.objectweb.org/svnroot/ecom/extension/jmx Préliminaires Testez et comprenez les
exemples JMX fournis dans le répertoire.
Utilisez la console JMX JConsole.exe (
http://java.sun.com/javase/6/docs/technotes/guides/management/index.html) fournie dans le JDK de puis la
version 5.0 et pour butiner les MBeans enregistrés sur les MBeanServers des exemples. Vous pourrez
utiliser également les consoles concurrentes MC4J,jManage, XtremJ, ...
Utilisez La console VisualVM qui surpasse la JConsole. Elle permet de butiner les MBeans et d'exécuter les
plugins écrits pour elle et pour la JConsole.
Vous pourrez aussi vous connecter sur les connecteurs JMX de vos serveurs JOnAS (La JMXServiceURL
est service:jmx:rmi:///jndi/rmi://hostname:1099/jrmpconnector_jonas) pour explorer les managed objects d'un
serveur J2EE conformément au JSR 77.
Remarque : la console SNMP vu en TP Réseaux peut servir à parcourir la MIB de la machine virtuelle de
vos serveurs via l'adaptateur (voir le JSR 163.et également
http://java.sun.com/javase/6/docs/technotes/guides/management/snmp.html) Instrumentation simple en
fonction des étapes réalisées précédenment. Instrumentation simple d'une application Java application
Développez et enregistrez un MBean (ie standard MBeans, dynamic MBeans, MXBeans, annotated
MBeans (JSR 255)) au POJO Supplier qui a été développé pour les fournisseurs écrits en Java (JMS,WS,
RESTFul) pour monitorer des indicateurs relatifs au traitement des commandes : nombre de commandes
recues, .... Instrumentation simple d'une webapp WAR JavaEE Développez et enregistrez un MBean (ie
standard MBeans, dynamic MBeans, MXBeans, annotated MBeans (JSR 255)) que vous enregistrez
comme un javax.servlet.ServletContextListener pour monitorer des élèments de l'activité des filters de votre
webapp (geolocalisation des visiteurs, ...). Instrumentation simple d'une EAR JavaEE Développez et
enregistrez un MBean (ie standard MBeans, dynamic MBeans, MXBeans, annotated MBeans (JSR 255)) au
SessionBean EuroConvertor (produit à l'étape ??) pour monitorer les 3 indicateurs relatifs au
rafraichissement de la table des parités variables avec le Web Service CurrencyConvertor. Ces indicateurs
sont : nombre de rafraichissements réussis, nombre de rafraichissements en échec, temps en seconde du
dernier rafraichissement réussi. Instrumentation simple des serveurs CORBA Lisez premièrement le
chapitre 21 "Using Java Management Extentions (JMX)" du guide de programmation de JacORB
(%JACORB_HOME%docProgrammingGuideProgrammingGuide.pdf
Cette sous-extension consiste à ajouter un MBeanServer à votre GenericServer CORBA. Ce MBeanServer
sera pourvu de connecteurs et d'adaptateurs qui seront activés au démarrage à partir d'un fichier
d'initialisation.
Vous utiliserez ensuite le MBeanServer pour superviser quelques éléments notoires de vos serveurs (POA,
POM, Intercepteur). Vous définirez pour chacun de ces éléments un MBean permettant des récupérer des
statistiques diverses et variées (A vous de les imaginer !). Essayez de diversifier les types de MBeans
développés (ie standard MBeans, dynamic MBeans, annotated MBeans (JSR 255)).
Vous pourrez écrire des MBeans utilisant les types
• TabularDataSupport
http://java.sun.com/javase/6/docs/api/javax/management/openmbean/TabularDataSupport.html
• CompositeDataSupport
http://java.sun.com/javase/6/docs/api/javax/management/openmbean/CompositeDataSupport.html
Réalisation du déploiement dynamique des servants (déprécié) Cette sous-étape consiste à implémenter le
déploiement dynamiques des servants. Les servants pourront être déployer dynamiquement à partir
d'archives présentes sur Internet. Pour cela, vous utiliserez les MLet à la façon de JBoss. Réalisation d'un
adaptateur pour IIOP Cette sous-étape consiste à réaliser un adaptateur IIOP. Pour cela, vous définirez
l'interface IDL de cet adaptateur afin de pourvoir faire l'essentiel des opérations que permet de faire un
connecteur. Ensuite, vous implémenterez cet adaptateur au moyen d'un dynamic MBean qui implémente
l'interface MBeanRegistration pour pouvoir récupérer la référence du MBeanServer. Vous testerez cet
adaptateur en écrivant un client simple (de type Shell ou GUI) permettant d'explorer les MBeans enregistrés
ObjectWeb - Wiki - Main - frjmx
-3-

sur le MBeanServer. Réalisation d'un adaptateur RESTFul Cette sous-étape consiste à réaliser un
adaptateur RESTFul. Pour cela, vous définirez les URL GET et POST pour naviguer et modifier les
propriétés des MBeans et pour invoquer leurs opérations. Par exemple:
java.lang:type=OperatingSystem --> GET /java/lang/OperatingSystem java.lang:type=Memory --> GET
/java/lang/Memory java.lang:type=GarbageCollector,name=Copy --> GET
/java/lang/GarbageCollector/Copy set Verbose=true in java.lang:type=ClassLoading --> PUT
/java/lang/ClassLoading?Verbose=true invoke gc() of java.lang:type=Memory --> GET
/java/lang/Memory/gc
Lire•http://blogs.sun.com/jmxnetbeans/entry/restful_access_to_jmx_instrumentation
Réalisation d'un plugin dans la JConsole (déprécié) pour superviser les serveurs CORBA Cette sous-étape
consiste à réaliser un un onglet dans la JConsole 6.0 pour superviser les serveurs CORBA via les MBeans
que vous avez développés. Pour cela, vous utilisez l'API com.sun.tools.jconsole pour ajouter cet onglet sous
la forme d'un JConsolePlugin. Pensez à réutiliser les grapheurs disponibles dans l'implémentation de la
JConsole. Réalisation d'un plugin dans la VisualVM pour superviser le composant EuroConvertor Cette
sous-étape consiste à réaliser un p dans la VisualVM pour superviser le MBean du composant
EuroConvertor que vous avez développés. Pour cela, vous utilisez l'API de la VisualVM pour ajouter cet
onglet sous la forme d'un Visual Plugin???. Pensez à réutiliser les grapheurs disponibles dans
l'implémentation de la VisualVM. Le plugin doit être conditionné sous la forme d'un plugin NetBeans.
Sécurisation de l'administration et du déploiement Activez la sécurité pour les connecteurs et n'autorisez
que le déploiement d'archives signées. JMX avec ANT Utilisez les tâches JMX de Catalina (livrées avec
Apache TomCat) pour automatiser les interactions avec les MBeanServers de vos passerelles et de vos
serveurs (déploiement des bundles, ...). Pour cela , vous pouvez tester l'exemple se trouvant dans le
répertoire exemplesjmxjmxant de la distribution du projet. JMX avec ANT et LDAP Utilisez les tâches JMX
de Catalina et la tache JNDI réalisée pour automatiser la configuration et le déploiement de plusieurs
serveurs à partir d'informations stockées par un annuaire LDAP. MEJB Pour terminer cette étape, vous
pourrez regarder rapidement l'exemple j2eemanagement qui est dans le répertoire examples de JOnAS. Cet
exemple illustre l'usage de MEJB pour explorer les managed objects d'un serveur J2EE. Un MEJB peut être
perçu comme un adaptateur JMX. Ils sont spécifiés par le JSR 77.
Documentation
Pour comprendre JMX, vous pouvez vous reporter
• aux transparents du cours sur JMX : http://www-adele.imag.fr/users/Didier.Donsez/cours/jmx.pdf
• à la documentation de JMX : http://java.sun.com/javase/6/docs/technotes/guides/jmx/spec.html
• au tutorial de SUN sur JMX :
http://java.sun.com/javase/6/docs/technotes/guides/jmx/tutorial/tutorialTOC.html
• au tutorial de XMOJO sur JMX : http://www.xmojo.org/products/xmojo/tutorials/docs/index.html
• aux exemples du JDK : http://java.sun.com/javase/6/docs/technotes/guides/jmx/examples.html
• aux «Best Practices »: http://java.sun.com/products/JavaManagement/best-practices.html
http://www.ftponline.com/javapro/2005_01/magazine/features/cpeltz/
• aux transparents de Rickard Öberg sur JBoss et JMX :
http://www.ece.uic.edu/~cpress/jmx/Oberg_jmx_jboss.ppt
• un recueil d'articles http://www.j2eeolympus.com/J2EE/JMX/JMX.jsp
• AOP@Work: Performance monitoring with AspectJ:
http://www-128.ibm.com/developerworks/java/library/j-aopwork10/ +
http://www-128.ibm.com/developerworks/java/library/j-aopwork12/
• Un exemple d'usage des MLet :
http://www.adventnet.com/products/javaagent/help/mp_agent/jmx/j_jmx_mlet_service.html
http://www.adventnet.com/products/javaagent/examples/jmx/mlet/readme.html
• Java Specification Request (JSR) 163 http://jcp.org/en/jsr/detail?id=163 +
http://java.sun.com/j2se/1.5.0/docs/guide/management/SNMP.html
• chapitre 21 « Using Java Management Extentions (JMX) » du guide de programmation de JacORB
(%JACORB_HOME%docProgrammingGuideProgrammingGuide.pdf
• JMX sur Wikipedia http://en.wikipedia.org/wiki/Java_Management_Extensions
Bonus track
Installation et Démarrage de JManage Téléchargez et décompressez JManage depuis
http://www.jmanage.org
ObjectWeb - Wiki - Main - frjmx
-4-

Positionnez vous dans ./bin Ouvrez 3 shells ou cmd.exe pour y lancer les commandes
cd ./bin startTestApp startup (username admin et password 123456) jmanage (username admin et
password 123456)
Ouvrez la page web du serveur http://localhost:9090 (username admin et password 123456)
Ajoutez une application JSR 160 "Add Application>JSR160 Application" avec pour nom testApp et pour URL
service:jmx:rmi:///jndi/rmi://localhost:9999/testApp
Connectez vous à testApp
Vous pouvez utilisez keygen pour charger le password d'origine.
Mise en oeuvre de l'administration avec JMX (Administration et supervision des serveurs JavaEE) (fr)
Creator: xwiki:XWiki.donsez Date: 2007/08/24 07:33
Last Author: xwiki:XWiki.donsez Date: 2012/01/11 11:46
Copyright (c) 2005-2006, ObjectWeb Consortium
ObjectWeb - Wiki - Main - frjmx
-5-