Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
UNIVERSITE DES SCIENCES ET TECHNOLOGIES DE LILLE
Master 1 informatique parcours Génie Mathématique et Informatique
Réalisation d'une interface de gestion des
utilisateurs en Ruby on Rails
Rapport de stage du 3 septembre au 5 octobre 2007
Société Esolys hébergé à Cré’Innov
Tuteur en entreprise : M. Jean-Sébastien Galloo
Rapport de stage réalisé par des étudiants en Master 1 GMI :
Vincent Fretin
Jérôme Maslak
Remerciements
Nous tenons à exprimer nos sincères remerciements à M. Denis Leroy, Conseiller
de Projets Emergents d'entreprise à Cré'Innov, qui nous a intégré avec gentillesse et bonne
humeur.
Nous remercions particulièrement notre maitre de stage, M. Jean-Sébastien
Galloo, notre tuteur en entreprise et gérant d'Esolys, pour nous avoir fait confiance en ce
qui concerne l'implantation des solutions que nous proposions.
Table des matières
Introduction.......................................................................................................5
1. Présentation de l'entreprise...........................................................................6
1.1. Entreprise...................................................................................................................6
1.2. Méthodes de travail...................................................................................................6
1.2.1. Le développement incrémentiel.........................................................................6
1.2.2. Le Pair Programming.........................................................................................6
1.2.3. L'eXtreme programming....................................................................................7
1.2.4. Subversion..........................................................................................................7
2. Présentation du sujet.....................................................................................8
2.1. Le sujet......................................................................................................................8
2.2. Choix de la technologie employée.............................................................................8
2.2.1. Ruby...................................................................................................................8
2.2.2. Rails...................................................................................................................8
3. Recherche des outils...................................................................................10
3.1. Internationalisation..................................................................................................10
3.1.1. Solutions existantes..........................................................................................10
3.1.2. Solution retenue...............................................................................................10
3.2. Génération automatique de formulaire....................................................................11
3.2.1. Introduction......................................................................................................11
3.2.2. Active Scaffold................................................................................................11
3.3. Annuaire OpenLDAP..............................................................................................12
3.3.1. Introduction......................................................................................................12
3.3.2. Implantation.....................................................................................................13
3.4. Fenêtres Ajax...........................................................................................................14
3.4.1. Solution prévue................................................................................................14
3.4.2. Solution finalement retenue.............................................................................14
4. Travail réalisé.............................................................................................15
4.1. Fonctionnalités de l'application...............................................................................15
4.2. Perspective d'évolutions..........................................................................................22
5. Déploiement...............................................................................................23
5.1. Installation de Ruby + Rails + plugins....................................................................23
5.2. Déploiement de l'application...................................................................................24
5.2.1. Capistrano + Mongrel + Apache......................................................................24
5.2.2. Documentation + Mongrel + Apache..............................................................24
Conclusion.......................................................................................................25
Conclusion Vincent.........................................................................................26
Conclusion Jérôme..........................................................................................27
Bibliographie...................................................................................................28
Annexes...........................................................................................................29
Annexe 1 : Script d'installation........................................................................................30
Annexe 2 : Documentation pour le déploiement.............................................................32
Introduction
Dans le cadre de notre année de M1, nous devions réaliser un stage d'un mois afin
de nous initier au monde de la recherche.
Notre stage s'est déroulé à Esolys hébergé au pré-incubateur de l'USTL Cré'Innov. Cette
organisation permet un accompagnement dans la démarche et l'étude des divers aspects
du projet du créateur d'entreprise avec l'université.
Esolys a pour mission de devenir un leader du développement avec Ruby on Rails sur la
région lilloise.
Le stage consistait à développer une interface d'administration ergonomique de
type « Web 2.0 » pour une application web de gestion de la salle blanche de l'IEMN
(Institut d'Electronique de Microélectronique et de Nanotechnologie).
Une salle blanche est une pièce ou une série de pièces où la concentration particulaire
est maitrisée afin de minimiser l'introduction, la génération et la rétention de particules à
l'intérieur. Les paramètres tels que la température, l'humidité et la pression relative sont
également maintenus à un niveau précis.
Cette interface devait être développé avec le jeune framework Ruby on Rails dont la
première version fût publiée en juillet 2004.
Nous voulions réaliser un stage qui se démarque des autres et ne pas travailler avec
un langage et des outils que nous connaissions déjà.
Le choix du stage s'inscrit dans notre projet professionnel qui est de suivre l'actualité en
matière de nouvelles technologies, plus communément appelé veille technologique.
Il s'agit là d'anticiper les évolutions et innovations dans le domaine du web.
Ce rapport s'organise de manière chronologique. Nous présenterons tout d'abord
succinctement l'entreprise, ainsi que le sujet du stage. Nous parlerons ensuite de la
recherche des outils nécessaires à notre projet. Nous aborderons les problèmes que nous
avons rencontrés, mais surtout les solutions que nous avons proposés. Nous enchainerons
sur le travail réalisé avec les fonctionnalités que nous avons développé. Enfin nous finirons
par la dernière étape qu'est le déploiement de la nouvelle application sur un serveur de
production.
1. Présentation de l'entreprise
1.1. Entreprise
Esolys est depuis Octobre 2007 une jeune entreprise. Sa mission est de devenir un
acteur majeur dans la proposition de solutions basées sur Ruby on Rails dans la
région lilloise.
Son premier projet de développement Ruby on Rails est l'interface d'administration web
qui gère les utilisateurs, les groupes et les différents processus de réalisations au laboratoire
de l'IEMN.
Son prochain projet est de développer un site communautaire pour la recherche
d'évènements sur la région lilloise et ses alentours.
1.2. Méthodes de travail
M. Jean-Sébastien Galloo nous avait laissé carte blanche quant à nos méthodes de
travail et des solutions que nous proposions.
Le framework Ruby on Rails que nous détaillerons dans la prochaine partie impose un
développement agile.
Cela implique notamment un développement incrémentiel. Chaque semaine nous
fournissions un compte rendu des avancés à notre tuteur. Il nous indiquait en retour les
corrections et améliorations à réaliser, ainsi que les nouvelles fonctionnalités à développer
pour la semaine suivante.
Nous avons pu mettre en pratique quelques idées de l'eXtreme Programming, du
développement incrémentiel, mais aussi du Pair Programming.
1.2.1. Le développement incrémentiel
Le principe fondamental est de ne pas tout spécifier avant le codage. Il faut
produire juste assez de spécifications pour implanter quelques fonctionnalités. Il faut
ensuite les essayer, demander l'avis aux utilisateurs puis enchainer sur un autre cycle
minimal de conception et de développement.
1.2.2. Le Pair Programming
La programmation se réalise en binôme. Les deux développeurs travaillent
ensemble sur la même partie de code et sur un même poste de travail.
Chaque développeur prend à tour de rôle le clavier. L'autre personne regarde
attentivement le travail du binôme et peut intervenir dès qu'il décèle une erreur de
conception.
Les avantages d'une telle méthode de travail sont multiples. En voici les principaux :
• Brainstorming : plus d'idées avec deux cerveaux.
• Une meilleure connaissance du sujet : chaque partenaire apporte ses propres
connaissances. Cela permet également une homogénéité des connaissances.
• Un meilleur code : les erreurs d'architecture de l'application tendent à être moins
fréquent.
• Une productivité accrue : les statistiques montrent que les développeurs sont deux
fois plus productifs pour une tâche donnée.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 6
1.2.3. L'eXtreme programming
L'eXtreme Programming (XP) est une méthode agile de gestion de projet
informatique adaptée aux équipes réduites avec des besoins changeants. Elle pousse à
l'extrême des principes simples.
En voici les 3 valeurs fondamentales à retenir :
• Tests unitaires : À chaque modification du code, les tests sont relancés. Si une
fonctionnalité n'est plus correct, elle est immédiatement détectée et permet ainsi
d'être corrigée rapidement.
• Refactoring (ou remaniement du code) : amélioration régulière de la qualité du
code. Permet pour la suite du projet d'avancer dans de meilleures conditions et
d'être plus rapide.
• Programmation en binôme : application de la méthode du Pair Programming.
1.2.4. Subversion
Il était impératif lorsque nous travaillions chacun sur notre poste, d'utiliser un
logiciel de gestion de version pour pouvoir s'y retrouver lors de nos modifications
respectives. Pour cela, nous avons décidé d'utiliser un standard : Subversion.
Subversion (en abrégé svn) est un logiciel libre publié sous licence Apache/BSD. Il a été
conçu pour remplacer CVS. Ses auteurs s'appuient volontairement sur les mêmes concepts
(notamment sur le principe du dépôt centralisé et unique) et considèrent que le modèle de
CVS est le bon, et que seule son implémentation est en cause.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 7
2. Présentation du sujet
2.1. Le sujet
Le sujet du stage était le développement d'une interface d'administration
ergonomique pour une application web de gestion de la salle blanche de l'IEMN.
Cette application permettrait la gestion en temps réel de l'ensemble des étapes de
réalisation de dispositifs électroniques avancés développés dans ce laboratoire (150
utilisateurs minimum). Ces dispositifs sont confectionnés dans la salle blanche sous
atmosphère contrôlée.
Cette application doit être facilement accessible à toute personne du laboratoire
quel que soit son niveau en informatique. Dans ce but, il était nécessaire de réaliser une
interface d'administration ergonomique, intuitive et très simple d'utilisation basée sur
les technologies web dites « 2.0 » (méthodologie Ajax en particulier et librairie javascript
script.aculo.us : drag'n drop, auto-complétion...).
Ce stage avait pour but de développer une partie de cette application en Ruby on
Rails : la partie administration des personnes et des équipes des différents laboratoire de
l'IEMN.
2.2. Choix de la technologie employée
Ruby on Rails a été choisi pour les qualités que possèdent ses deux composantes
que sont Ruby et Rails.
Nous préciserons dans les sections suivantes les atouts de cette technologie.
2.2.1. Ruby
Ruby est un langage de programmation interprété orienté objet.
La philosophie de Ruby est la suivante :
• Toute donnée est un objet, y compris les types.
• Toute fonction est une méthode.
• Toute variable est une référence à un objet.
2.2.2. Rails
Ruby on Rails, également appelé RoR ou Rails est un framework web libre écrit
en Ruby. Il suit le motif de conception Modèle-Vue-Contrôleur.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 8
Rails est basé sur deux principes fondamentaux :
• Ne pas se répéter (ou DRY : Don't Repeat Yourself) : les éléments de l'application
ne doivent être qu'à un seul endroit. L'architecture MVC et la méta-programmation
en Ruby rendent cela possible.
• Convention plutôt que Configuration : il est inutile de préciser des détails
lorsqu'ils respectent des conventions établies. Rails exploite cela en proposant des
comportements par défaut pour la plupart de ses fonctionnalités.
Rails intègre parfaitement et facilement Ajax :
Ajax permet de réaliser des pages dynamiques avec Javascript et XML pour envoyer des
requêtes au serveur sans recharger la page dans le navigateur. Rails supporte Ajax et offre
plusieurs méthodes pour en simplifier l'utilisation.
La puissance du langage Ruby n'impose pas certaines limitations qui apparaissent
dans d'autres langages comme PHP.
Rails proposent de nombreuses méthodes pour simplifier l'écriture du code comme les
helpers.
La communauté est très active pour développer de nouveaux plugins ou helpers.
Le développement d'une application RoR se veut donc aisé et très rapide.
Ruby on Rails s'imposait donc pour le développement de cette application.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 9
3. Recherche des outils
3.1. Internationalisation
Le laboratoire de l'IEMN accueille de nombreux chercheurs étrangers. Il était
donc important que le site web soit au moins traduit en anglais.
3.1.1. Solutions existantes
Par défaut, Rails n'incorpore pas de mécanisme de gestion de
l'internationalisation du programme. Après une recherche sur la toile, nous avons
constaté qu'il existait de nombreuses solutions, chacune avec ses avantages et ses
inconvénients.
Notre premier choix s'était porté sur plugin Globalite
(http://www.railsontherun.com/globalite). Celui-ci nous semblait intéressant sur plusieurs
points :
• Gestion du changement de la langue.
• Gestion des formats de date.
• Gestion de la monnaie.
Des inconvénients majeurs sont cependant présents. Dans le fichier de traduction,
les phrases à traduire sont disposées les unes à la suite des autres, ce qui engendre ces
problèmes :
• Rend le fichier illisible pour un programme dont le nombre de phrases à traduire
est important.
• Les performances de lecture sont de plus en plus faibles à mesure que le fichier
devient de plus en plus conséquent.
3.1.2. Solution retenue
Nous avons finalement décidé d'utiliser un standard : gettext.
Gettext est la bibliothèque GNU d'internationalisation (i18n). Elle est couramment
utilisée pour écrire des programmes multilingues.
Il suffit de renseigner dans un fichier po la traduction de la phrase à traduire. Ce fichier
peut-être ouvert par un éditeur de texte classique ou spécialisé (comme PoEdit). Le
traducteur peut donc aisément réaliser sa tâche sans avoir de connaissances en
informatique.
Ce fichier po sera ensuite compilé en un fichier binaire mo. Les performances de lecture
seront donc optimum.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 103.2. Génération automatique de formulaire
3.2.1. Introduction
Nous voulions ajouter un peu de généricité à notre application. Nous avions donc
recherché un moyen de générer automatiquement un CRUD:
• Create
• Read
• Update
• Delete
Dans notre application, nous avons 2 modèles :
• Utilisateur
• Groupe
Nous voulions implanter un système qui dès que l'on désirerait ajouter un champ
supplémentaire, pour pouvoir par exemple modifier son âge, puisse se réaliser sans
modifier le fichier de vue d'extension rhtml.
3.2.2. Active Scaffold
Après quelques recherches, nous avions trouvé rapidement un plugin très utilisé par
la communauté Rails : Active Scaffold.
Ce plugin se base sur un modèle comme le modèle utilisateur dans notre application et
génère des vues complètes. Quelques options permettent de préciser si tel ou tel champ est
visible et/ou éditable.
Nous avions testé au début ce plugin avec un modèle utilisateur stocké dans une base de
données MySql. De cette façon, la communication se réalise grâce à ActiveRecord.
Nous avions ensuite testé avec notre serveur LDAP. Mais ici, la communication se réalise
grâce à ActiveLDAP. Il fallait redéfinir le mécanisme interne de communication entre ces
deux fonctions. Malheureusement, nous n'avions réussi car redéfinir le mécanisme
d'affichage des informations contenues dans un serveur LDAP. La mécanisme de
modification des données demandait des changements beaucoup trop interne de
ActiveLDAP.
La solution a donc été abandonnée.
Conclusion :
Au final, nos vues sont générées par nos soins.
Au fil et à mesure que nous développions, nous nous sommes aperçus que nous devions
apporter de nombreuses modifications aux vues pour satisfaire nos exigences.
Il aurait était donc nécessaire d'abandonner à un moment ou à autre Active Scaffold.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 113.3. Annuaire OpenLDAP
3.3.1. Introduction
Le stockage des utilisateurs et des groupes aurait pû être naturellement réalisé dans
une base de donnée MySql. Rails simplifie cette implantation grâce à son module
ActiveRecord.
Une base de données est constituée de données tabulaires. Il aurait été intéressant de
pouvoir disposer ces données de manière hiérarchisées.
De plus, ces données ne seront pas sujettes à être modifiées de manière régulière. Il était
donc intéressant de trouver une solution qui soit très performante en lecture et qui
pouvait l'être un peu moins en écriture.
Nous connaissions de nom le serveur LDAP (Lightweight Directory Access
Protocol) qui est un protocole qui permet l'interrogation et la modification des services
d'annuaire. Ce protocole repose sur TCP/IP. Un annuaire LDAP respecte généralement le
modèle X.500 édicté par l'UIT-T : c'est une structure arborescente dont chacun des nœuds
est constitué d'attributs associés à leurs valeurs.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 123.3.2. Implantation
Avec l'accord de M. Jean-Sébastien Galloo, nous avions donc décidé d'étudier cette
solution.
Nous avons étudié la version open source de LDAP : OpenLDAP.
L'étude du fonctionnement nous a pris pas mal de temps. En effet, la compréhension du
serveur est assez aisée au premier niveau mais sa configuration est néanmoins particulière.
Comme mentionné dans la section précédente, nous avions utilisé Active Scaffold
pour générer automatiquement nos vues.
Avec une base de données MySQL, aucun problème ne se posait. Avec un serveur LDAP,
rien ne marchait au début.
En effet, Rails gère l'échange de données avec MySQL grâce à son module ActiveRecord.
Or, ce module ne sait pas gérer la communication avec un serveur LDAP.
Nos recherches nous avaient amené au plugin ActiveLDAP. Comme son nom
l'évoque, ce dernier permet de communiquer avec un serveur LDAP de la même manière
qu'ActiveRecord communique avec une base de donnée relationnel.
Grâce à ce plugin, nous arrivions à afficher les informations de notre annuaire par
ActiveScaffold. L'édition en revanche ne marchait pas.
Nous nous étions plongé dans le code d'Active Scaffold afin de créer un adaptateur pour
ActiveLDAP. Nous avions écrit certaines fonctions pour adapter LDAP à la logique
relationnel d'une base de données, mais il nous était apparu qu'en réalité il était nécessaire
de modifier bien plus de comportements pour pouvoir le faire fonctionner. Certains
changements demandaient une investigation poussée au cœur de Rails. Pour ces raisons,
nous avons donc abandonné ActiveScaffold.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 133.4. Fenêtres Ajax
3.4.1. Solution prévue
M. Jean-Sébastien avait déjà utilisé pour ses précédentes créations de site web la
Prototype Window Class.
Elle permet d'ajouter des fenêtres dans une page HTML. Elle est basée sur
Prototype qui est un Framework JavaScript dont le but est de permettre au développeur
de créer des applications web dynamiques.
Cette librairie est rapidement devenu un choix standard pour implanter d'une manière
idéale la méthodologie AJAX.
Nous avions donc intégrer cette composante dans notre application Rails. Cependant, des
difficultés ont été rencontrées quant à son intégration.
En effet, la philosophie de Rails est de cacher de manière élégante tout le code Javascript
produit par l'application. Or pour utiliser cette librairie, il est impératif d'intégrer soi-même
son propre code JavaScript. Nous avions persisté dans cette voie en fournissant à Rails du
code JavaScript. Nous avions donc bien réussi à créer des fenêtres. Un problème
subsistait : les fenêtres générées envoyaient des codes de retour qu'il nous était
impossible de récupérés. Il nous était donc impossible d'interagir convenablement avec
ces fenêtres.
En résumé, voici pourquoi nous n'avons pas intégré cette solution :
• Intégration de code JavaScript contraire à la philosophie Rails.
• Mauvaise intégration dans un environnement Rails.
• Lenteur d'exécution des fenêtres.
En conclusion, cette solution convient parfaitement pour une application PHP mais se
trouve bien trop lourde de changements pour Rails.
Nous devions donc rechercher une solution alternative.
3.4.2. Solution finalement retenue
Nous avons retenu la solution ThickBox.
C'est un composant écrit en Javascript qui permet d'intégrer une fenêtre dans une page.
ThickBox se base sur la librairie jQuery, toolkit Ajax léger et rapide. Ses fonctions
permettent de montrer une image simple, plusieurs images, du contenu en file, le contenu
d'une iFrame ou bien du contenu généré par Ajax.
En résumé, nous avons opté pour cette solution pour les point suivants :
• Son intégration avec la philosophie Rails
• Sa légèreté et ses performances face à ses concurrents.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 144. Travail réalisé
Dans cette partie, nous allons dans un premier temps décrire les fonctionnalités
que nous avons développées. Dans un second temps, nous verrons les perspectives
d'évolution de l'application.
4.1. Fonctionnalités de l'application
Nous utilisons Thickbox pour le login.
Quand une action nécessite des droits, la ThickBox apparait à l'écran. La page s'assombrit
et devient inaccessible tant que l'utilisateur n'aura pas cliqué sur le bouton Connexion ou
Annuler.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 15Après s'être connecté, la page affiche les utilisateurs et les groupes actuels.
Si un utilisateur ou un groupe n'a pas envoyé de photo, une image par défaut
s'affiche.
La création d'un utilisateur est entièrement vérifiée au fur et à mesure grâce à des requêtes
Ajax.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 16Si l'utilisateur tente quand même de créer un utilisateur invalide, des messages
d'erreurs apparaissent et expliquent pourquoi. Chaque champ qui pose problème est
entouré d'un liseré rouge.
Tout le site web a été prévu pour fonctionner si l'utilisateur a désactivé JavaScript.
Le site web affiche dans ce cas un formulaire plus traditionnel, donc sans fonctions
JavaScript et requête Ajax.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 17L'upload de la photo est calqué sur le fonctionnement de celui de Gmail. Un popup apparait et demande la location du fichier. Ce popup affiche ensuite la photo et demande à l'utilisateur s'il désire valider son choix. Grâce à une requête Ajax et un peu de JavaScript, la photo de l'homme inconnue est mise à jour sans rechargement complète de la page. Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 18
La recherche d'un utilisateur met automatiquement la page à jour sans la recharger complètement grâce à Ajax. Avec le champ « Rechercher » vide : Avec le champ « Rechercher » qui contient la lettre 'j' : Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 19
Détails d'un utilisateur grâce à ThickBox :
La création d'un groupe repose sur les mêmes méthodes que celle d'un utilisateur.
Si le responsable a déjà été crée, on peut le sélectionner.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 20Détails d'un groupe. Tous les utilisateurs qui appartiennent à ce groupe sont aussi
listés.
Un clic sur le nom du responsable affiche son profil.
Si l'utilisateur utilise un navigateur avec une langue étrangère, le site le détecte et
change automatiquement la langue en correspondance :
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 214.2. Perspective d'évolutions
Il nous a été demandé la possibilité d'ajouter une personne en temps
qu'administrateur du site. Il s'agit en fait de promouvoir une personne, par exemple le
responsable d'une équipe, en tant qu'administrateur du site. C'est-à-dire lui donner la
possibilité de modifier toutes les informations liées aux personnes de l'équipe.
L'ajout du nom de cette personne en dur dans le code est un moyen simple de réaliser cela.
Celle solution manque cruellement de flexibilité.
En effet, il devrait être possible à un non programmeur de promouvoir un utilisateur
facilement à travers l'interface.
Une solution élégante à ce problème : assigner à chaque personne un ou plusieurs rôles.
Le stage arrivait à sa fin, nous n'avons pas pu traiter cette demande. Néanmoins,
nous donnons ci-après quelques pistes de recherches.
Le site suivant propose quelques solutions sous forme de plugins pour Rails :
http://technoweenie.stikipad.com/plugins/show/Acts+as+Authenticated
Le plugin Authorization Plugin (http://www.writertopia.com/developers/authorization)
nous paraissait être intéressant sur plusieurs points :
• Simplicité d'utilisation dans la philosophie Rails.
• Puissance d'utilisation (gère les expressions régulières pour définir les rôles).
Le travail réalisé constitue la base de l'application. Notre objectif était de gérer les
personnes des différents laboratoires de l'IEMN.
Le programme s'inscrit dans un plus grand projet.
Le problème actuel dans la procédure de réalisation de projet à l'IEMN, est que la personne
travaillant dans la salle blanche doit transférer manuellement les données d'un
ordinateur à un autre pour chaque étape de la conception. Cette organisation fait
perdre du temps, à tel point que certaines personnes ne prennent même plus la peine de
renseigner leur passage dans la salle blanche.
Le logiciel développé devrait pallier ces problèmes.
Cette interface web permettrait d'assister la personne dans les différentes étapes de
création d'un composant électronique au sein de la salle blanche de l'IEMN.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 225. Déploiement
Le déploiement se décompose en deux parties :
1. Installation de Ruby, Rails et des divers plugins utilisés par notre application.
2. Déploiement de l'application
5.1. Installation de Ruby + Rails + plugins
Lorsqu'il s'agit d'installer un programme sous Linux, plusieurs possibilités s'offre à
nous. Soit installer le programme à partir des sources, soit avec le gestionnaire de paquet
de la distribution. Cette dernière solution est d'ailleurs recommandé dans la plupart des
cas.
Comme nous travaillons sous la distribution Ubuntu, l'installation la plus facile et la plus
rapide se résume à la simple commande suivante :
sudo aptget install ruby rails
Avec cette commande, nous pensions pouvoir commencer tout de suite à
programmer, or ce ne fût pas le cas.
Par défaut, Rails utilise le serveur web WebRick, entièrement écrit en Ruby et
libre. Il est inclus dans Ruby depuis la version 1.8 du langage.
Ce serveur fonctionne très bien dans le cadre d'un environnement de développement mais
s'avère trop peu performant dans le cadre d'un environnement de production. Nous
avions donc décidé d'utiliser dès le début la solution préconisée dans le livre Ruby on Rails
aux éditions Eyrolles : installer le serveur Mongrel.
Le serveur HTTP Mongrel, écrit en Ruby et en C a été conçu pour être léger, rapide et
sécurisé.
Rails intègre son propre gestionnaire de paquets qui facilite la gestion des installations et
mises à jour des plugins : les gems.
L'installation du serveur Mongrel donne donc :
sudo gem install includedependencies mongrel
Malheureusement, nous nous sommes heurtés au problème d'incompatibilité de
versions. En effet, Mongrel demande la dernière version de Ruby. L'installation de Ruby
par le gestionnaire de paquets ne nous fournit pas sa dernière version en date.
Nous avons donc décidé d'abandonner l'installation de Ruby par le gestionnaire de
paquets. Nous avons créé un script bash qui récupère sur Internet les dernières version de
Ruby, Rails et des autres plugins utilisés par notre site web. Le script s'occupe ensuite de
compiler et d'installer tout le nécessaire de manière automatique.
Vous pourrez retrouver ce script en annexe 1.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 235.2. Déploiement de l'application
La machine contient maintenant tout ce qu'il faut pour pouvoir exécuter une
application Ruby on Rails.
Il nous manque le plus important : l'application elle-même. La dernière étape est donc de
transférer l'application sur le serveur et de configurer ce dernier pour pouvoir répondre
aux requêtes.
Pour déployer notre application, nous avions étudié la solution préconisée dans le
livre Ruby on Rails aux éditions Eyrolles à savoir l'utilisation du plugin Capistrano.
Dans la section suivante, nous vous présentons pourquoi cette solution n'a pas été
retenu. Nous concluons sur la solution finalement prise.
5.2.1. Capistrano + Mongrel + Apache
Capistrano est un utilitaire de déploiement d'applications Web, recommandé pour
les applications de Ruby on Rails.
Capistrano devait donc déployer les fichiers de notre site web et configurer
l'environnement du serveur.
Notre serveur utilise Mongrel comme serveur interne et Apache comme serveur
web frontal.
Capistrano devait donc se charger aussi de mettre à jour ces processus.
La tentative de déploiement avec cet utilitaire nous avait déçu. En effet, Capistrano réalise
de nombreuses tâches que nous ne souhaitions pas ou des tâches avec des paramètres
incorrects non modifiables.
Nous avons donc décidé de créer une documentation qui précise un déploiement
parfaitement contrôlé sur un serveur Linux Ubuntu.
5.2.2. Documentation + Mongrel + Apache
La documentation que nous avons écrit directement en anglais s'est voulue assez
exhaustive.
Nous y détaillons les points suivants :
• Comment déployer le serveur OpenLDAP et tester sa bonne mise en
fonctionnement.
• Installer Rails et les gems utilisées par le site web.
• Déployer les fichiers du site web sur le serveur.
• Initialiser un cluster Mongrel.
• Configurer et démarrer Apache.
Ainsi de cette manière nous maitrisons le déploiement de notre application sans surprise.
Vous pourrez retrouver cette documentation en annexe 2.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 24Conclusion
Ce stage labo d'un mois s'est déroulé dans le cadre de notre formation en Master 1
parcours GMI. Nous avons réalisé ce stage à Esolys, hébergé au pré-incubateur de
l'USTL Cré'Innov.
Le but du stage était de nous initier au monde de la recherche. En effet, après notre
Master 1 nous aurons le choix entre continuer en Master 2 Pro en vue de travailler en
entreprise, ou en Master 2 Recherche pour devenir chercheur.
Nous avons travaillé pour M. Jean-Sébastien Galloo qui est aujourd'hui chef
d'entreprise dans le secteur de l'informatique. De part son ancien statut de chercheur au
laboratoire de l'IEMN, il connaissait bien les besoins que possédait ce laboratoire.
Actuellement, la gestion des utilisateurs, des groupes et des différents étapes des processus
de fabrication de la salle blanche de l'IEMN sont gérées manuellement. Des besoins de
gestion et d'organisation se ressentaient.
Ce stage devait donc mettre en place la structure et les premiers développements d'une
interface web ergonomique de type « Web 2.0 ».
En effet, ces chercheurs ont une formation en électronique et ne maitrisent pas forcément
bien l'outil informatique. Notre interface d'administration des utilisateurs et des groupes se
devait donc d'être la plus intuitive et ergonomique possible. C'est ce vers quoi nous
avons tendu à réaliser tout le long de ce stage.
La technologie principale utilisée est Ruby on Rails. La jeunesse du framework
Rails nous a amené tout le long du stage à rechercher sur Internet des solutions qui
n'étaient pas intégrées dans le framework par défaut, ou à les développer nous-mêmes.
Nous pensons surtout à l'intégration d'un serveur LDAP dans notre projet.
Nous nous sommes aussi occupés du problème du déploiement. Il a été simplifié
par la création d'une documentation.
Le projet connaitra encore un long développement pour gérer les différents
processus de la salle blanche. Ce développement sera certainement réalisé par d'autres
stagiaires.
Vous pouvez maintenant apprécier nos conclusions personnelles.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 25Conclusion Vincent
Ce stage d'un mois s'achève sur un sentiment de travail bien fait. En effet nous
avons fini les objectifs demandés au départ et avons même basé l'application sur un
annuaire LDAP que j'avais proposé d'incorporer dès le début.
J'avais envie d'étudier un peu comment utiliser un annuaire LDAP car c'est un outil très
intéressant pour avoir un serveur d'authentification commun à plusieurs applications. Il
est par exemple possible de posséder un seul login et mot de passe pour se connecter à la
fois à un dépôt subversion, un forum, un blog et un wiki.
J'ai choisi ce stage sur Ruby on Rails (RoR) pour expérimenter un nouveau
framework en vogue dans la création d'interfaces web.
Ce stage s'inscrit logiquement dans mon projet professionnel qui est de faire du
développement web et devenir expert consultant dans une ou plusieurs technologies. J'ai
d'ailleurs travaillé cet été sur le framework Zope/Plone pour la création de portails
collaboratifs dans l'entreprise Ecréall où j'avais fait mon premier stage en janvier.
Ayant une expérience dans ces deux frameworks, je peux voir les forces et
faiblesses de chacun d'eux.
RoR permet d'utiliser avec une facilité déconcertante les technologies Ajax :
modification d'une zone spécifique d'une page sans recharger complètement celle-ci, ou
bien des effets visuels comme l'indication de changement d'un champ de formulaire. Je
pense que RoR est très bien pour un besoin spécifique, du sur mesure. Il manque
cependant de nombreuses choses dans ce framework et le seul moyen d'y remédier et
d'installer des plugins additionnels.
Quant à Zope/Plone, c'est un très bon CMS avec de nombreuses fonctionnalités
incluses par défaut, ce qui le rend incontournable pour un portail collaboratif complexe.
Pour le niveau de difficulté de compréhension et d'apprentissage, les deux
frameworks ne jouent pas dans la même catégorie. Pour Zope/Plone, je dirai qu'il faut un
apprentissage d'au moins deux mois. Au contraire RoR s'apprend très vite. En deux
semaines avec un bon livre, il est aisé de réaliser rapidement une application web.
J'ai pu faire profiter Jérôme de mon expérience en Pair Programming que j'ai
acquis lors de mon travail cet été. J'aime beaucoup cette méthode de développement car
elle permet aux deux développeurs de partager leurs connaissances, ainsi que de trouver
des idées plus facilement.
J'adore apprendre de nouvelles choses. Le fait que le développement web est un
domaine sans cesse en évolution me plait donc beaucoup. Ce stage me conforte dans l'idée
de continuer sur cette voie.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 26Conclusion Jérôme
J'ai choisi ce stage d'une part pour avoir une première expérience en technologie
web, et d'autre part pour pratiquer un framework prometteur basé sur Ajax.
En effet, après avoir eu une première expérience dans le monde de la grande
distribution chez Cylande avec l'utilisation de technologies éprouvées, ce stage a été
l'occasion de découvrir le milieu de la recherche et ses technologies innovantes.
Comme je ne connaissais que les bases de html, css, Javascript, php et MySQL au
travers de quelques cours et réalisations personnelles, ce stage m'a demandé un
investissement personnel important à savoir la lecture et l'assimilation du livre de
référence de Dave Thomas de 797 pages ...
Programmer avec un framework aussi jeune que Rails est une expérience vraiment
enrichissante. En effet, il ne suffit pas de se rendre sur des sites traditionnels comme
developpez.com avec ses FAQ très fournies pour trouver les réponses à ses problèmes. Il
fallait par exemple se rendre sur de multiples sites de passionnés qui réalisent de la veille
technologique. Toutes les réponses étaient loin de se trouver sur Internet. Des réflexions
se sont posées tout au long du stage. Je pense notamment à l'intégration de la gestion de
l'internationalisation.
Ce stage m'a permis de travailler en équipe et d'appliquer la méthode de travail du
Pair Programming. Nous étions particulièrement complémentaires. Vincent avec son
expérience dans le développement web, et pour ma part la connaissance de Ruby on
Rails qui nous assuré un démarrage rapide. Ce qui a été particulièrement important vu le
peu de documentations existantes et la courte durée du stage.
Ruby on Rails (et plus globalement tout ce qui se rapporte avec les méthodes
Ajax) m'a montré les nouvelles capacités que proposeront les sites webs ces prochaines
années. Ce qui constituera un atout supplémentaire pour ma future carrière
professionnelle.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 27Bibliographie
Ruby on Rails
• Dave Thomas, David Heinemeier Hansson. Ruby on Rails 2e édition, Eyrolles,
2007, 780 p.
• Site officiel de Ruby on Rails : http://www.rubyonrails.org/
• Tutoriels sur Ruby : http://ruby.developpez.com/
Subversion
• Site officiel de subversion : http://subversion.tigris.org/
• Tutoriel sur l'utilisation de subversion :
http://artis.imag.fr/Members/Xavier.Decoret/resources/svn/index.html
Plugins
• Page sur le plugin ActiveLDAP :
http://wiki.rubyonrails.org/rails/pages/ActiveLDAP
• Using Gettext To Translate Your Rails Application :
http://manuals.rubyonrails.com/read/chapter/105
• Plugin pour avoir des noms de champ humanisé dans les erreurs de formulaire
: http://agilewebdevelopment.com/plugins/human_attribute_override
• Plugin pour générer un mot de passe aléatoire prononçable :
http://agilewebdevelopment.com/plugins/phonemic_passwords
• Boite Ajax ThickBox de la librairie jQuery : http://jquery.com/demo/thickbox/
OpenLDAP
• Tutoriel d'installation d'openldap sur Ubuntu : http://doc.ubuntu-fr.org/slapd
• Getting Started with LDAP :
http://www.linuxdevcenter.com/pub/a/linux/2001/11/08/ldap.html
• Explications sur LDAP :
http://www-sop.inria.fr/semir/personnel/Laurent.Mirtain/ldap-livre.html
• RFC utile pour connaitre les attributs que l'on peut utiliser dans les entrées
LDAP : http://www.ietf.org/rfc/rfc2256.txt
• OpenLDAP Software 2.3 Administrator's Guide:
http://www.openldap.org/doc/admin23/
Gestion des rôles
• simple authentication generator plugin for Ruby on Rails :
http://technoweenie.stikipad.com/plugins/show/Acts+as+Authenticated
• a flexible way to add authorization to Rails :
http://www.writertopia.com/developers/authorization
Selenium IDE
• Extension Firefox pour réaliser des tests fonctionnels :
http://www.openqa.org/selenium-ide/
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 28Annexes
Annexe 1 : Script d'installation
# http://blog.mondragon.cc/articles/2007/02/03/compiling-ruby-1-8-5-w-openssl-on-
debian-etch-testing-and-freebsd-in-home
# http://www.ruby-forum.com/topic/90083
# http://blog-perso.onzeweb.info/2007/03/28/multiples-ruby/
# Install dependencies with apt-get
apt-get update
apt-get install build-essential libreadline5-dev zlib1g-dev libssl-dev libldap2-dev
libmagick++9-dev
RUBY_VERSION=1.8.6
RUBYGEMS_VERSION=0.9.4
RUBYLDAP_VERSION=0.9.7
RMAGICK_VERSION=1.15.10
## You don't have to edit below normally ##
PKG=$PWD/packages
if [ ! -e $PKG ]; then mkdir -p $PKG; fi
# Download the last version of stable ruby on http://www.ruby-lang.org/
RUBY_SITE=ftp://ftp.ruby-lang.org/pub/ruby/1.8
RUBY_TB=ruby-$RUBY_VERSION.tar.bz2
RUBY_DIR=ruby-$RUBY_VERSION
# http://rubyforge.org/projects/rubygems/
RUBYGEMS_SITE=http://rubyforge.org/frs/download.php/20989
# don't add a final slash for this one
RUBYGEMS_TB=rubygems-$RUBYGEMS_VERSION.tgz
RUBYGEMS_DIR=rubygems-$RUBYGEMS_VERSION
#
RUBYLDAP_SITE=http://mesh.dl.sourceforge.net/sourceforge/ruby-ldap
RUBYLDAP_TB=ruby-ldap-$RUBYLDAP_VERSION.tar.gz
RUBYLDAP_DIR=ruby-ldap-$RUBYLDAP_VERSION
RUBY_HOME=/usr/local/ruby-$RUBY_VERSION
RB=$RUBY_HOME/bin/ruby
if [ -e $RUBY_HOME ]; then
rm -rf $RUBY_HOME
fi
if [ ! -e $PKG/$RUBY_TB ]; then
wget -P $PKG $RUBY_SITE/$RUBY_TB
if [ $? -ne 0 ]; then exit 1; fi
fi
cd /tmp/ &&\
rm -rf $RUBY_DIR &&\
tar xvf $PKG/$RUBY_TB &&\
cd $RUBY_DIR &&\
./configure --prefix=$RUBY_HOME &&\
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 29make &&\
make install &&\
cd - &&\
rm -rf $RUBY_DIR
if [ $? -ne 0 ]; then exit 1; fi
# install rubygems
if [ $? -ne 0 ]; then exit 1; fi
if [ ! -e $PKG/$RUBYGEMS_TB ]; then
wget -P $PKG $RUBYGEMS_SITE/$RUBYGEMS_TB
if [ $? -ne 0 ]; then exit 1; fi
fi
cd /tmp/ &&\
rm -rf $RUBYGEMS_DIR &&\
tar xvf $PKG/$RUBYGEMS_TB &&\
cd $RUBYGEMS_DIR &&\
$RB setup.rb
cd - &&\
rm -rf $RUBYGEMS_DIR
if [ $? -ne 0 ]; then exit 1; fi
# install ruby-ldap
if [ $? -ne 0 ]; then exit 1; fi
if [ ! -e $PKG/$RUBYLDAP_TB ]; then
wget -P $PKG $RUBYLDAP_SITE/$RUBYLDAP_TB
if [ $? -ne 0 ]; then exit 1; fi
fi
cd /tmp/ &&\
rm -rf $RUBYLDAP_DIR &&\
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 30Annexe 2 : Documentation pour le déploiement
==============================
Deployment on an Ubuntu Server
==============================
You will need the following packages:
apt-get install ssh subversion slapd ldap-utils apache2
OpenLDAP
========
First, you have to set up an openldap server
-----------------------------------------------------
As root, edit /etc/ldap/slapd.conf and change all occurences of "dc=nodomain" by
"dc=example,dc=com" or by your own domain. ("dc=example,dc=com" is used in \*.ldif)
Then add rootdn and rootpw keys:
rootdn "cn=admin,dc=example,dc=com"
rootpw secret
or if you don't want a plain/text password, crypt it with slappasswd an copy the resulting
string, e.g :
rootpw {SSHA}v6s7gnyXfA50jwILOaRiODHqUsA54I9U
Delete existing database and start the slapd daemon
--------------------------------------------------------------
as root:
/etc/init.d/slapd stop
if you executed slapd manually => "ps aux|grep slapd" and kill the pid
delete existing database and start the slapd daemon::
rm -rf /var/lib/ldap/*
/etc/init.d/slapd start
check it's running with "ps aux", if not, execute slapd manually.
Create the base of the LDAP tree and fill it with some users and groups
-------------------------------------------------------------------------------------
ldapadd -x -W -D"cn=admin,dc=example,dc=com" -f base.ldif
If you want to add 3 users and 2 groups to test the server:
ldapadd -x -W -D"cn=admin,dc=example,dc=com" -f users_groups.ldif
Verify the openldap server is set up correctly:
ldapsearch -xLLL -w secret -D"cn=admin,dc=example,dc=com" -b
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 31"dc=example,dc=com" uid=johndoe
Should return:
dc=example,dc=com" uid=john.doe
dn: uid=john.doe,ou=users,dc=example,dc=com
uid: john.doe
objectClass: inetOrgPerson
cn: John Doe
givenName: John
[...]
For more documentation on openldap
---------------------------------------------
- http://doc.ubuntu-fr.org/slapd
- http://www.linuxdevcenter.com/pub/a/linux/2001/11/08/ldap.html
- http://www-sop.inria.fr/semir/personnel/Laurent.Mirtain/ldap-livre.html
- http://www.ietf.org/rfc/rfc2256.txt
- http://www.openldap.org/doc/admin23/
Install rails and required gems
======================
execute the script:
svn co http://crome.homelinux.com/devsvn/scripts
cd scripts
./install_ruby.sh
Install your rails app on the server
========================
ssh to your server, I suggest you to create a specific user to launch your mongrels server:
adduser rails
Optional, if you want to not type yout password every time you connect to the server,
create a RSA public/private keys on your local machine:
ssh-keygen -t rsa
and transfer it to the server:
ssh rails@server_ip "mkdir .ssh; chmod 0700 .ssh"
scp .ssh/id_rsa.pub rails@server_ip:.ssh/authorized_keys
On the server, check out the latest version of your rails app:
cd /home/rails
svn co http://crome.homelinux.com/devsvn/adminusers/trunk adminusers
mkdir adminusers/tmp/{cache,pids,sessions,sockets}
Now configure config/ldap.yml with the same config as /etc/ldap/slapd.conf
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 32This rails app depends on active_ldap (http://rubyforge.org/projects/ruby-activeldap
). To install it, install gettext's gem, build ruby-ldap and then build active_ldap.
This is done by the install_ruby.sh script above.
Generate mo files:
rake makemo
Start the server:
ruby script/server
And try to create, edit, destroy some users and groups.
If all is alright, shutdown the server with CTRL+C
Mongrel Cluster
============
Now we want to configure a mongrel cluster, here we are two mongrels, one on 8000 port,
and the other on 8001 listening to 127.0.0.1:
mongrel_rails cluster::configure -e production -p 8000 -a 127.0.0.1 -N 2
-c /var/www/adminusers
This command generate the config/mongrel_cluster.yml file which is used by
mongrel_rails cluster::* commands
To start it, in your rails app directory (here /home/rails/adminusers):
mongrel_rails cluster::start
Now you should have access to the two rails instances at http://127.0.0.1:8000/admin and
http://127.0.0.1:8001/admin
To stop it:
mongrel_rails cluster::stop
To restart it:
mongrel_rails cluster::restart
Apache
======
Then create a new VirtualHost /etc/apache2/sites-available/adminusers (see example in the
doc directory on subversion) and make a symlink in sites-enabled like this:
cd /etc/apache2/sites-enabled/
ln -s ../sites-available/adminusers 001-adminusers
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 33Enable proxy_balancer and proxy_http modules:
a2enmod rewrite
a2enmod proxy_balancer
a2enmod proxy_http
and edit /etc/apache2/mods-available/proxy.conf to allow proxy for specific domain
domain or ip, for example:
AddDefaultCharset off
Order deny,allow
#Deny from all
Allow from 127.0.0.1, 192.168.68.4
#Allow from .example.com
Finally, reload apache:
/etc/init.d/apache2 reload
Now you should have access to a rails instance with http://127.0.0.1/admin
Selenium tests
===========
There exists some functional tests in the test/selenium directory.
You need to install the "Selenium IDE" extension for firefox.
The tests work only with the english site, so you need to select "en" for the default
language in the firefox preferences.
To execute the test suite:
firefox -chrome "chrome://selenium-ide/content/selenium/TestRunner.html?
test=file:///home/pseudo/adminusers/test/selenium/TestSuite.html&auto=true&baseU
RL=http://localhost:3000/"
Localization
=========
To update the pot and all po files:
rake updatepo
To update a translation, edit the corresponding po file.
If you want to create a new translation, for example russian:
mkdir po/ru
msginit -i po/adminusers.pot -o po/ru/adminusers.po
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails 34Vous pouvez aussi lire
