Documentation

Documentation
Projet ASR : 2012-2013
Construction d’un système réparti
multi-échelle
Réalisé par :
Ji LIU
Eric GUILLAUME
Mohamed RIAHI
Encadrants:
Sébastien LERICHE
Sam ROTTENBERG
Contenu
Déployer des applications Java Web Dynamiques sur Cloud Foundry ................................................... 0
Présentation de la documentation...................................................................................................... 0
1) Présentation de Cloud Foundry .......................................................................................................... 1
1.1) Cloud Foundry est un cloud Platform as a Service (PaaS) ............................................................ 1
1.2) Description de la plateforme fournie par Cloud Foundry ............................................................ 2
1.3) Les limitations de Cloud Foundry ................................................................................................. 2
1.4) L'infrastructure de Cloud Foundry ............................................................................................... 2
2) Créer une application déployable sur Cloud Foundry ......................................................................... 4
2.1) Plusieurs types d'applications au choix ........................................................................................ 4
2.2) Créer un projet Web Java ............................................................................................................. 4
2.3) Exporter le projet sous forme d'un fichier .war ........................................................................... 6
3) Quelles techniques pour utiliser Cloud Foundry ? .......................................................................... 7
4) Installation de VMC ............................................................................................................................. 8
4.1) Installation de Ruby et RubyGems ............................................................................................... 8
4.1.1) Installation sous Ubuntu ....................................................................................................... 8
4.1.2) Installation sous Mac OS X .................................................................................................... 8
4.1.3) Installation sous Windows .................................................................................................... 9
4.2) Installation de VMC .................................................................................................................... 10
4.2.1) Installation sous Ubuntu ..................................................................................................... 10
4.2.2) Installation sous MacOSX .................................................................................................... 10
4.2.3) Installation sous Windows .................................................................................................. 10
5) Utilisation de VMC............................................................................................................................. 12
5.1) Connexion à Cloud Foundry ....................................................................................................... 12
5.2) Principales commandes de VMC ................................................................................................ 13
6) Déploiement d'une application Java avec VMC ................................................................................ 14
6.1) Création des services associés ................................................................................................... 14
6.2) Le déploiement de l'application ................................................................................................. 14
6.3) Gérer le cycle de vie d'une application ...................................................................................... 16
7) Utilisation du plugin Eclipse .............................................................................................................. 17
7.1) Installation du plugin Eclipse ...................................................................................................... 17
7.2) Utilisation du plugin Eclipse ....................................................................................................... 18
8) Communiquer depuis l'extérieur vers un service RabbitMQ du cloud ............................................. 23
8.1) Première étape........................................................................................................................... 23
1
8.2) Installation du tunnel Caldecott ................................................................................................. 23
8.2.1) Installation de Caldecott sous Windows ............................................................................. 23
8.2.2) Installation de Caldecott sous Ubuntu ................................................................................ 23
8.2.3) Installation de Caldecott sous Mac OS X ............................................................................. 24
8.3) Création du tunnel vers un service ............................................................................................ 24
9) Nos premières applications utilisant les communications du RabbitMQ du cloud .......................... 25
9.1) Présentation des applications .................................................................................................... 25
9.2) Déploiement du projet sur le cloud ........................................................................................... 27
9.3) Paramétrage du code source ..................................................................................................... 28
9.3.1) Paramétrage sous Windows................................................................................................ 28
9.3.2) Paramétrage sous un Unix .................................................................................................. 28
9.4) Déploiement du projet en local ................................................................................................. 29
9.5) Etape finale................................................................................................................................. 29
Références : ........................................................................................................................................... 31
2
Déployer des applications Java Web Dynamiques sur Cloud Foundry
Présentation de la documentation
Dans cette documentation nous avons utilisé la notation suivante pour les commandes Shells:
$ commande
indique une commande dans le Shell natif de l’OS
$ruby commande
indique une commande dans un Shell supportant Ruby
Ces Shells ne sont pas les mêmes suivant l'OS, nous donnerons toutes les précisions dans la partie
installation de VMC.
1) Présentation de Cloud Foundry
1.1) Cloud Foundry est un cloud Platform as a Service (PaaS)
Cloud Foundry est un cloud de type PaaS, c'est à dire qu'il fournit lui-même l'infrastructure
matérielle et la plateforme de programmation c'est à dire: les frameworks et les serveurs
d'applications. Le développeur n’interagit pas avec ces derniers qui sont fonctionnels et à jour. Il n'a
pas non plus à ce soucier de l'infrastructure sous-jacente qui est scalable et gère les défaillances. Il
doit uniquement se concentrer sur ses codes et sur ses librairies additionnelles.
Le schéma ci-dessous décrit le partage des tâches entre l’utilisateur et le Cloud.
Figure 1 - Pile des fonctionnalités du cloud - Image réalisée par nous-même avec des logos libres
Dans notre cas, nous allons déployer des applications Java qui utilisent le serveur Apache Tomcat et
le service de communication qu'est le broker de message RabbitMQ. Nous serons obligés de
développer des applications Web, c'est à dire des applications lancées dans une servlet. Dans Cloud
Foundry nous pouvons réaliser soit des applications Java Web classique, soit des applications Java
Web avec le framework Spring, nous utiliserons les premières.
Cloud Foundry est édité par VMWare dont il utilise toutes les technologies de virtualisation et de
datacenter. C'est une vitrine du groupe qui semble s'amener vers un modèle commercial de type
freemium.
Sa structure est réputé très innovante et en fait un des PaaS les plus en vue. De plus il est
OpenSource et reçoit le soutien d'une forte communauté. Cependant, le nombre de frameworks et
de services reste encore assez limité et la documentation ne présente pas toutes les possibilités du
cloud. Toutefois, de nombreux blogs et forums permettent d'obtenir les réponses souhaitées.
1
1.2) Description de la plateforme fournie par Cloud Foundry
On peut déployer sur Cloud Foundry jusqu'à 20 applications qui possèdent toute un nom unique et
qui sont accessibles à l'URL suivante: http://nomDeLApplication.cloudfoundry.com. Ces applications
ne sont pas des programmes en état de fonctionnement mais des codes Web qui se lanceront
lorsqu’une requête HTTP sur leur URL sera reçue par le serveur Tomcat.
Chaque application peut être déployée sous plusieurs instances virtuelles toutes prêtes à répondre à
toute requête HTTP et qui se situeront sur différentes machines. La scalabilité c'est à dire la
répartition des tâches à effectuer entre ces instances est réalisée automatiquement par le Cloud. Ces
instances sont au nombre maximum de 16.
Il faut également noter que Cloud Foundry ne fournit que 2 Runtime java, java 6 et java 7.
1.3) Les limitations de Cloud Foundry
Pour éviter une trop forte utilisation de son service gratuit Cloud Foundry à mis en place des
limitations supplémentaires.
Nous avons déjà vu que nous étions limités à 20 applications et 16 instances.
Il y a également des limitations de mémoire vive à 2Go pour toutes les instances lancées. Il faut de
plus affecter une limitation mémoire pour chaque application, souvent de 512Mo. On ne peut créer
plus de 256 fichiers. On dispose de 2Go de mémoire physique pour ces derniers.
En ce qui concerne les services tel RabbitMQ et MySQL ils ont tout deux une limitation de 128Mo.
En revanche vous n'avez vraiment aucune limitation sur l'utilisation des 4 cœurs CPU fournit ni sur
l'utilisation du réseau et de son débit de 100Mo/s.
En ce qui concerne le développement d’applications, vous avez de nombreuses limitations
concernant les entrées/sorties. Il n’est en effet impossible d'avoir accès à aucun port directement
grâce à un binding sur un port TCP ou à un WebService. En effet ces ports étant partagés entre
plusieurs instances de plusieurs utilisateurs, ils sont bloqués. On peut seulement recevoir des
requêtes HTTP sur le port 80 qui sont transmises aux servlets via le serveur Tomcat.
De plus, tous nos programmes sont des programmes Web, ils ne peuvent être lancés, ils sont lancés
par le serveur Tomcat automatiquement à chaque fois qu'une requête HTTP sur leur URL est reçue.
Toutefois, il est tout de même possible d'y insérer des threads parallèles qui réalisent des calculs
gourmands en ressources pendant plusieurs journées sans interruption.
1.4) L'infrastructure de Cloud Foundry
App Exec Engine est le nom donné au système qui gère l'exécution de vos application sur une
machine généralement avec un CPU quadricore de type Intel Xeon.
Les Cloud Controller gèrent l'authentification, les droits d'accès pour l'accès à son compte, le
déploiement d'une application, et l'accès aux services fournis tels RabbitMQ.
Les Request Router gèrent le DNS du cloud, ils réalisent en temps réel la correspondance entre l'url
de l'application web déployée et les App Exec Engine des différentes instances qui peuvent être
lancées pour répondre à la requête.
2
Le Health Manager vérifie régulièrement si les applications et leurs instances sont dans un bon état
de fonctionnement.
Enfin, Cloud Foundry offre de nombreux services tels MySQL et RabbitMQ dont les instances et les
données sont sur des machines à part.
L'image suivante décrit l'infrastructure de Cloud Foundry avec le vocabulaire officiel.
Figure 2 - Infrastructure de Cloud Foundry - Image issue de la documentation de cloudfoundry.org
3
2) Créer une application déployable sur Cloud Foundry
2.1) Plusieurs types d'applications au choix
Il existe deux types d'applications Java déployables: les applications Web Java et les applications Web
Java avec le framework Spring.
Spring a une connexion à RabbitMQ et aux autres services plus intuitive et automatique mais il
nécessite d'englober toutes nos classes dans son framework et avec ses propres fonctions
d’utilisation des services. Ainsi un code classique utilisant RabbitMQ n’est pas portable sur le cloud
en utilisant Spring : il faut réécrire tout le code utilisant RabbitMQ.
Nous recommandons donc l'utilisation d'applications Java Web simple que nous allons expliciter dans
la partie suivante.
2.2) Créer un projet Web Java
Attention: Nous conseillons vivement d'utiliser Eclipse Enterprise Edition qui possède des outils pour
exporter automatiquement et de façon fiable des projets web.
Pour créer un tel projet, allez dans le menu Eclipse File -> New -> Other. Une fenêtre s'ouvre, ouvrez
le dossier Web et choisissez Dynamic Web Project comme sur l'image ci-dessous.
Cliquez sur Next, rentrez le nom de votre application et enfin sélectionnez Dynamic web module
version 2.5 comme sur l’image ci-dessous.
4
Votre premier projet a été créé !
Vous pouvez maintenant ajouter des servlets et des classes java de manière classique. Si vous désirez
utiliser des librairies jar, il faut les mettre dans le dossier WebContent/WEF-INF/lib/ afin qu'elles
soient exportées dans le fichier .war que vous déploierez sur Cloud Foundry ; elles seront également
immédiatement ajoutées au ClassPath de votre projet.
5
2.3) Exporter le projet sous forme d'un fichier .war
Afin de pouvoir déployer votre application, il va falloir l'exporter dans un fichier .war, pour cela allez
dans Eclipse dans le menu File -> Export, le menu suivant s'ouvre alors:
Cliquez alors sur le dossier Web puis sur WAR File et renseignez le nom et la location de l'archive
désirée. Nous allons maintenant voir quelles sont les techniques qui permettent de déployer et
d'administrer vos applications sur le Cloud.
6
3) Quelles techniques pour utiliser Cloud Foundry ?
Pour utiliser ce Cloud, il faut d'abord vous inscrire avec votre adresse email pour recevoir un mot de
passe associé.
Vous pouvez réaliser cette étape à la page suivante: https://my.Cloud Foundry.com/signup.
Il existe ensuite deux méthodes pour déployer des applications sur Cloud Foundry.
La première est l'utilisation de VMC qui est un système en ligne de commande très puissant mais qui
nécessite un peu d'apprentissage et l'installation de nombreux logiciels.
La deuxième est l'utilisation du plugin Eclipse STS qui est très ergonomique.
Attention : si vous désirez réaliser des programmes communiquant de manière automatique avec le
RabbitMQ de Cloud Foundry il vous faudra très vraisemblablement avoir installé et utilisé les deux
outils cités ci-dessus.
Nous allons expliquer ces deux méthodes en commençant par l'installation de VMC.
7
4) Installation de VMC
Afin d'installer le plugin VMC, il faut tout d'abord installer les environnements Ruby et RubyGems.
Ci-dessous nous avons expliqué comment installer ces derniers sous Ubuntu, Max OS X et Windows.
D'autres OS sont disponibles, au début de chacune des sous-parties décrivant l'installation de VMC
ci-dessous, nous avons joint un lien ou est décrit l'installation sous de nombreux OS.
4.1) Installation de Ruby et RubyGems
Sous Mac OS X, Ubuntu, tous les Linux et tous les Unix, Ruby s'installe au sein du Shell natif, ainsi
lorsque nous vous demanderons d'utiliser une commande $ruby commande vous devez alors la
taper dans votre Shell natif, ce n'est cependant pas le cas sous Windows, plus d'explication sont
données dans la partie 3.1.3) Installation sous Windows.
Beaucoup d'autres OS disposent de ces technologies, pour comprendre comment les installer allez
sur http://docs.Cloud Foundry.com/frameworks/ruby/installing-ruby.html.
4.1.1) Installation sous Ubuntu
Installez RubyGems ainsi: $ sudo apt-get install ruby-full rubygems
Mettez ensuite les variables d'environnements de votre Shell à jour en ajoutant à votre .bashrc ceci:
export PATH=$PATH:/var/lib/gems/1.8/bin
Relancez votre terminal et testez ensuite si RubyGems est dans le path avec la commande : $ which
gem
Il est conseillé pour Ubuntu 10.04 ou supérieur de mettre à jour RubyGems grâce aux commandes
suivantes :
$ sudo gem install rubygems-update
$ sudo /var/lib/gems/1.8/bin/update_rubygems
4.1.2) Installation sous Mac OS X
Si vous disposez de Mac OS X avec une version supérieur à la 10.5, Ruby et RubyGems sont déjà
installés et paramétrés, il n'y a rien à faire.
8
4.1.3) Installation sous Windows
Commencez par télécharger et installer Ruby Installer for Windows qui contient RubyGems sur
http://www.rubyinstaller.org/
Installez le package en lançant le fichier téléchargé, acceptez la licence puis cochez uniquement
l'option d'ajout de Ruby à votre path comme sur l’image ci-dessous:
Sous Windows, le Shell disposant de Ruby ne sera pas votre Shell classique, mais celui que vous
pouvez ouvrir en faisant: Windows -> Ruby-<<numéro de version>> -> Start Command Prompt with
Ruby comme sur l'image suivante :
9
Attention : A chaque fois que nous écrirons une commande ainsi: $ruby <commande> dans ce
tutoriel, souvenez bien que sous Windows ce n'est pas dans le Shell natif que vous devez la lancer.
Mettez ensuite à jour Ruby et RubyGems ainsi:
$ruby gem update --system
4.2) Installation de VMC
L'installation de VMC est très simple et rapide une fois Ruby et RubyGems installés.
Si vous désirez l'installer sur d'autres OS qu'Ubuntu, Windows et Mac OS X, rendez vous ici :
http://docs.Cloud Foundry.com/tools/vmc/installing-vmc.html#installing-vmc-procedure.
4.2.1) Installation sous Ubuntu
Tapez simplement dans votre Shell la commande suivante:
$ sudo gem install vmc
4.2.2) Installation sous MacOSX
Tapez simplement dans votre Shell la commande suivante:
$ sudo gem install vmc
4.2.3) Installation sous Windows
Tapez simplement dans votre Shell Ruby la commande suivante:
Attention : A chaque fois que nous écrirons une commande ainsi: $ruby <commande> dans ce
tutoriel, souvenez bien que sous Windows ce n'est pas dans le Shell natif que vous devez la lancer.
$ruby gem install vmc
L'installation peut prendre quelque temps avant d'afficher le résultat suivant :
10
11
5) Utilisation de VMC
5.1) Connexion à Cloud Foundry
Attention : Vous devrez réaliser ces opérations à chaque ouverture de Shell afin d'utiliser le cloud.
Vous devez d'abord vous connecter au serveur de Cloud Foundry ainsi:
$ruby vmc target https://api.Cloud Foundry.com
Authentifiez vous avec : $ruby vmc login puis entrez l’email et votre mot de passe de votre compte
Cloud Foundry comme expliqué au début de la partie 3) Quelles techniques pour utiliser Cloud
Foundry ?
Vérifiez ensuite que vous êtes bien authentifié avec la commande $ruby vmc info qui vous renverra
des informations liées au cloud comme sur l'image ci-dessous:
12
5.2) Principales commandes de VMC
Cette liste contient les principales commandes de VMC, la liste complète est disponible sur :
http://docs.Cloud Foundry.com/tools/vmc/vmc-quick-ref.html
$ruby vmc passwd
permet de modifier votre mot de passe
$ruby vmc help
permet d'afficher l'aide
$ruby vmc apps
affiche la liste des applications déployées avec leurs informations
$ruby vmc create-service
$ruby vmc services
permet de créer un nouveau service
affiche la liste des services crées
$ruby vmc logs appName
permet de voir les logs de votre application
$ruby vmc stats appName
permet de voir des informations précises sur une seule application
13
6) Déploiement d'une application Java avec VMC
Pour déployer une application, nous devons dans l'ordre: créer l'application, créer les services que
nous voulons utiliser tel RabbitMQ s’ils ne l’ont pas déjà été, et enfin déployer l'application en la liant
aux dits-services.
6.1) Création des services associés
On crée un service en sa laissant guider par la commande suivante: $ruby vmc create-service il faut
bien évidemment associer au service un nom unique et noter de côté ce nom.
$ruby vmc services permet de lister les services afin de vérifier si la création a bien été effectuée.
Le dessin ci-dessous montre le cas de création du service serviceTest.
6.2) Le déploiement de l'application
Pour déployer l'application, commencez par l'exporter dans un format .war comme décrit dans la
partie 2.3) Exporter le projet sous forme d'un fichier .war. Le fichier doit avoir le nom de votre
application qui sera également son futur URL, par exemple: nomDeLApplication.war.
Pour plus d'informations sur comment générer une application Java Web compatible avec Cloud
Foundry, allez à la partie 2) Créer une application déployable sur Cloud Foundry.
14
Ouvrez ensuite votre Shell et placez vous dans le dossier du .war, tapez :
$ruby vmc push applicationName
Répondez aux questions demandées, [Yn] indique que yes est la réponse par défaut si vous tapez
entrée.
Renseignez le type d'application que vous utilisez: ici java web avec le Runtime java 7. Mettez au
moins 256Mo pour la limite de mémoire vive.
Vous pourrez également au cours de cette étape construire différentes instances de services tel un
broker de message RabbitMQ puis lier ces dernières à votre application.
Attention : Il est obligatoire de lier l’application aux pour qu’elle puisse les utiliser.
La sauvegarde de la configuration créera un fichier manifest.yml dans le dossier de votre .war, ce
fichier contiendra les paramètres de votre déploiement pour automatiser cette étape
ultérieurement.
Si vous désirez lier une application à un service, utilisez :
$ruby vmc bind-service nomService nomApplication
Testez ensuite avec $ruby vmc apps le déploiement de votre application.
Félicitation !, elle est maintenant disponible sur applicationName.Cloud Foundry.co, la capture
d'écran suivante présente toute cette étape de déploiement.
15
6.3) Gérer le cycle de vie d'une application
$ruby vmc push appName permet de mettre à jour l'application avec un nouveau .war
$ruby vmc delete appName permet de supprimer l'application
16
7) Utilisation du plugin Eclipse
7.1) Installation du plugin Eclipse
Premièrement, il vous faut naturellement Eclipse.
Attention : je vous conseille vivement Eclipse Entreprise Edition, il exporte naturellement des
librairies jar au sein d'un war correctement ce qui est bien compliqué avec la version standard
d'Eclipse.
Ouvrez Eclipse, allez dans Help -> Eclipse market place. Puis tapez dans Find Cloud Foundry et
cliquez sur Install une fois que vous avez trouvez le plugin, comme dans l'image ci-dessous.
Laissez-vous guider, et une fois l'installation terminée redémarrez Eclipse.
17
Il faut ensuite créer le serveur Cloud Foundry dans Eclipse.
Ouvrez la vue Serveur si elle ne l'est pas déjà en faisant: Windows -> Show View -> Other -> Server
Puis faites New -> Server et renseignez les champs comme ci-dessous.
Cliquez Next, spécifiez l'email et le mot de passe de votre compte sur Cloud Foundry et terminez.
7.2) Utilisation du plugin Eclipse
Dans la vue Serveur, double cliquez sur le serveur Cloud Foundry, vérifiez que votre email et mot de
passe sont bien insérez puis cliquez sur Connect comme ci-dessous, cela vous permettra de rentrez
en connexion avec le service de Cloud Foundry.
18
Cliquez ensuite sur l'onglet Applications, l'écran suivant s'affiche alors (vous n'aurez probablement
pas encore d'applications):
19
Cette fenêtre permet de gérer les services et les applications présentes dans votre Workspace. Il
permet également de lier ces applications avec vos services su le Cloud. Vous pouvez également
créez des services tel un système de messagerie RabbitMQ en appuyant sur le bouton entouré en
rouge. Nous vous conseillons de les créer tout de suite si vous souhaitez les utiliser ultérieurement.
Un peu en bas à droite en cliquant sur le lien Remote Systems View vous pouvez voir l'arborescence
des applications que vous avez déployées sur Cloud Foundry comme ci-dessous.
20
Pour déployez une application Java sur CloudFoundry, il suffit de faire glisser l'icône du projet sur le
serveur Cloud Foundry comme suit.
Une fenêtre s'ouvre comme ci-dessous et nous demande de valider le nom de l'application et la
mémoire que nous désirons réserver, nous conseillons ne pas prendre en dessous de 256M.
21
Cliquez sur le bouton Next et indiquez les services auxquels vous désirez lier votre application puis le
type de votre application (ici "java web") et la version du Runtime java désiré (Cloud Foundry
supporte java 6 et 7).
En revenant sur l'onglet Applications de la fenêtre du serveur Cloud Foundry, vous pouvez voir en
haut à droite sur le schéma suivant les boutons start, restart et update and restart qui vous
permettent de gérer le cycle de vie de votre application et de la mettre à jour.
22
8) Communiquer depuis l'extérieur vers un service RabbitMQ du cloud
8.1) Première étape
Afin de réaliser cette communication, il faut d'abord créer avec Eclipse un service RabbitMQ comme
expliqué à la partie 7) Utilisation du plugin Eclipse.
Il faut ensuite sélectionner les informations de connexion au service que sont son nom, son mot de
passe et le nom du virtualhost qui sont statiques.
8.2) Installation du tunnel Caldecott
Afin de communiquer depuis un ordinateur distant vers le cloud, Cloud Foundry utilise le système de
tunnel Caldecott qu'il vous faut installer puis lancer afin d'utiliser à distances les services du PaaS.
Nous allons expliquer comment installer ce tunnel sur Windows, Ubuntu et Mac OS X. Pour les autres
distributions de Linux l’installation est similaire à celle sous Ubuntu.
8.2.1) Installation de Caldecott sous Windows
Premièrement, allez sur rubyinstaller.org/downloads téléchargez le development kit. Double
cliquez ensuite sur le fichier téléchargez et extrayez le dans le dossier C:\DevKit. Ouvrez un terminal
Windows et mettez vous dans ce dossier.
Suivez
ensuite
les
instructions
https://github.com/oneclick/rubyinstaller/wiki/Development-Kit
de
la
page
Ouvrez ensuite le Shell Ruby et exécutez la commande: $ruby gem install caldecott --no-rdoc --no-ri
8.2.2) Installation de Caldecott sous Ubuntu
Exécutez les commandes suivantes dans l'ordre:
$ sudo apt-get install g++ libssl-dev
$ruby sudo gem install caldecott --no-rdoc --no-ri
$ sudo gem install tunnel-vmc-plugin
Notez que la première commande varie peu sous d'autres distributions Linux et que la deuxième et la
troisième restent identiques et que toutes trois elles permettent une installation sous toute
distribution.
23
8.2.3) Installation de Caldecott sous Mac OS X
Il faut d'abord avoir Xcode installé sur son Mac.
Tapez ensuite: $ruby sudo gem install caldecott --no-rdoc --no-ri
8.3) Création du tunnel vers un service
Créer un tunnel vers par exemple le service de nom rabbitmq-123 se réaliser simplement ainsi:
$ruby vmc tunnel rabbitmq-123
A la suite de cette commande de nombreuses données sont affichées dont ces dernières:
Ne lancez aucun clients en répondant 1 comme montré dans l'encadré rouge sur l'image ci-dessus.
Toutes les informations de connexions dont vous avez besoin pour notamment RabbitMQ sont
présentes. L'image suivante montre un exemple d'utilisation de ces paramètres.
Il y a une autre manière de réaliser ce paramétrage. Vous pouvez également utiliser le nom de
service, le mot de passe le virtualhost et le port 10000 que vous a fourni Eclipse (bien qu’ils soient
différents) avec comme Host toujours l’adresses IP locale 127.0.0.1.
Attention: Le tunnel étant construit localement, il faut toujours donner à l'hôte l'adresse IP locale
127.0.0.1
24
9) Nos premières applications utilisant les communications du
RabbitMQ du cloud
9.1) Présentation des applications
Nous avons réalisé un ensemble de 3 projets qui vont nous servir lors de la démonstration pendant la
soutenance. Ces projets se trouvent sur le SVN dans le dossier src/code_final.
Le premier de ces projets se nomme application_locale, il permet de lancer deux applications
différentes qui envoient et reçoivent des messages à des destinataires à travers une interface en
ligne de commande. Ce projet a été empaqueté dans le fichier application_locale.jar. Il communique
de façon automatique en générant le tunnel Caldecott de façon automatique.
Le deuxième projet se nomme application_parametres et est contenu dans le fichier
application_parametres.war il doit être déployé sur Cloud Foundry et permet de récupérer les
paramètres de connexion de façon dynamique pour des applications extérieures à Cloud Foundry.
Le troisième projet se nomme application_cloud, il est exporté dans le fichier application_cloud.war.
Il est accessible par URL et présente une interface graphique ergonomique comme suit :
Les applications permettent de communiquer soit depuis le Cloud, soit depuis un ordinateur
personnel. Il faut d’abord renseigner le nom que l’on veut utiliser dans le champ «Nom de cette
application » puis cliquer sur commencer et ensuite rentrer le nom du destinataire et le message à
publier et cliquer sur Publish. Il est également possible de recevoir un message en cliquant sur le
bouton Get one.
25
Le schéma ci-dessous décrit les étapes permettant les communications entre ces différents projets.
Figure 3 - Représentation des communications de nos applications - Image réalisée par nous même
On s’aperçoit dans un premier temps que les paramètres de communication statiques sont
demandés à l’application application_parametres sur le cloud. L’application locale crée alors s’il ne
l’a pas déjà été un Proxy du tunnel chargé de créer le tunnel Caldecott vers le RabbitMQ sur le cloud.
C’est ensuite à travers ce tunnel que passerons toutes les instructions d’utilisation de RabbitMQ tel la
déclaration d’une queue, son écoute, où encore l’envoi d’un message.
De son côté l’application sur le cloud communiquera via le framework Spring et ses méthodes avec le
RabbitMQ du cloud.
On peut également lancer plusieurs instances de l’application sur le Cloud, à partir de plusieurs
onglets de navigateur et lancer plusieurs instances de cette application sur une machine locale. Il est
ainsi possible d’effectuer toute sorte de communication entre des applications externes et internes à
Cloud Foundry. Le schéma suivant présente toutes ces possibilités.
26
Figure 4 - Représentation des communications de nos applications - Image réalisée par nous même
9.2) Déploiement du projet sur le cloud
Vous devez disposer d’un compte sur Cloud Foundry et avoir crée un service RabbitMQ dont vous
devrez vous souvenir du nom.
Dans un premier temps il faut déployer sur Cloud Foundry l’application application_parametres.war.
Si l’url http://application_parametres.cloudfoundry.com est déjà utilisée il faudra modifier le nom de
l’application et du .war. Il faut ensuite noter de coté cet URL.
Il faut ensuite déployer l’application application_cloud sur le cloud en la liant à votre service
RabbitMQ. Rendez vous ensuite à l’URL obtenue, vous obtiendrez la petite interface graphique cidessus.
27
9.3) Paramétrage du code source
Prenez le projet présent sur le SVN dans le dossier src/code et appelé application_locale et copiez-le
sur votre machine puis importez le dans Eclipse. Il faut ensuite le paramétrer pour qu’il puisse lancer
automatiquement un programme et accéder à RabbitMQ. Ce paramétrage dépend de l’OS sur lequel
vous vous trouvez.
9.3.1) Paramétrage sous Windows
Il faut modifier le fichier application_locale/cmd1.bat aux lignes 16 et 17 en mettant votre email et
votre mot de passe de compte Cloud Foundry à la place de [email protected] et de tspprojet. A la
ligne 17 remplacez rabbitmq-7705d par le nom du service rabbitmq que vous avez créé.
Copier ensuite les fichiers application_locale/cmd1.bat et application_locale/cmd2.bat dans
$(ruby_home)/bin/ avec $(ruby_home) le dossier où vous avez installé Ruby.
Puis modifier le fichier application_locale/src/connecteur/Tunnel.java. A ligne 98 remplacez
D:\\Ruby193\\bin\\cmd1.bat par $(ruby_home)\\bin\\cmd1.bat. A ligne 99 remplacez
D:\\Ruby193\\bin\\cmd2.bat par $(ruby_home)\\bin\\cmd2.bat avec $(ruby_home) le chemin
vers le dossier où a été installé Ruby.
Il faut ensuite réexporter avec Eclipse le projet dans un fichier application_locale.jar comme suit :
Après l'installation on peut le lancer par taper la commande: $ java -jar application_locale.jar.
9.3.2) Paramétrage sous un Unix
Créez d'abord un tunnel avec vmc.
Dans le fichier /src/connecteur/Him.java,à ligne 16 supprimer Tunnel.etablir(); à la ligne 21
remplacez Tunnel.get_username(),Tunnel.get_password(),Tunnel.get_virtuelhost() par les strings
correspondant à votre email, votre mot de passe et le virtualhost de votre RabbitMQ sur Cloud
Foundry. Faites exactement les mêmes remplacements à la ligne 26.
Attention : La partie automatisant l’établissement automatique du Tunnel sous un Unix ne
fonctionne pas encore correctement.
28
9.4) Déploiement du projet en local
Attention : L’application locale ne fonctionne que sous Windows. Nous n’avons pas réussi à
automatiser la génération automatique du tunnel Caldecott sous Windows.
Vous devez d'abord disposer d’un ordinateur avec Ruby et RubyGems installé, pour cela reportez
vous à la partie 4.1) Installation de Ruby et RubyGems.
Votre ordinateur doit également avoir VMC installé, pour cela reportez
Installation de VMC.
vous à la partie 4)
Il faut ensuite copier les fichiers cmd1.bat et cmd2.bat dans le dossier $(ruby_home)/bin avec
$(ruby_home) le chemin vers le dossier où a été installé Ruby.
9.5) Etape finale
Premièrement, exportez le projet dans une archive jar exécutable, en allant dans le menu Eclipse File
-> export.
La fenêtre ci-dessus s’ouvre alors, ouvrez le dossier Java et sélectionnez Runnable JAR file.
L’utilitaire ci-dessous s’ouvre alors, sélectionnez dans Launch configuration la classe Him de ce
projet.
29
Il ne vous reste plus qu’à lancer le programme dans un Shell avec la commande: $ java -jar
application_locale.jar.
30
Références :
http://www.cloudfoundry.com/
http://www.cloudfoundry.org/
http://www.rabbitmq.com/
https://github.com/cloudfoundry/vcap-java-client.git/
http://www.ruby-lang.org/fr/
http://rubygems.org/
31