Rapport final - Projet SpagoBI

Projet M1
Sujet 21 : Développement d'un logiciel simplifié de
type Business Object
Professeur Tuteur : Thierry Spriet
1
2
3
4
5
6
7
8
9
Introduction....................................................................................................................4
1.1
Cadre du projet .......................................................................................................4
1.2
Objectif...................................................................................................................4
1.3
Système existant .....................................................................................................4
1.4
Utilisateurs..............................................................................................................4
1.5
Organisation ...........................................................................................................4
1.6
Rappel sur les solutions envisagées .........................................................................5
La plate-forme SPAGOBI...............................................................................................5
2.1
Présentation ............................................................................................................5
2.2
Fonctionnement du Projet avec SpagoBI.................................................................5
2.3
Installation..............................................................................................................6
2.3.1
Installation de Tomcat avec eXo-Portal ...........................................................6
2.3.2
Installation de SPAGOBI ................................................................................6
2.4
Démarrage ..............................................................................................................7
Extraction des données : Talend Open Studio..................................................................7
3.1
Pourquoi Talend Open Studio? ...............................................................................7
3.2
Présentation de Talend Open Studio........................................................................8
3.3
Intégration avec SpagoBI......................................................................................12
BIRT ............................................................................................................................13
4.1
Présentation ..........................................................................................................13
4.2
Installation............................................................................................................13
4.3
Utilisation et Intégration avec SPAGOBI..............................................................14
4.4
Création de rapports pré générés ...........................................................................14
4.4.1
Introduction...................................................................................................14
4.4.2
Créer une source et un jeu de données. ..........................................................15
4.4.2.1 Définition de la source de données ............................................................15
4.4.2.2 Extraction à partir d'une base de données...................................................15
4.4.2.3 Manipulation d'un jeu de données (data set)..............................................17
4.4.3
Conception d'un rapport ................................................................................18
4.5
Créer une librairie .................................................................................................18
4.6
Créer un template de rapports................................................................................19
4.7
Ajouter un rapport à SpagoBI................................................................................20
4.7.1
Introduction...................................................................................................20
4.7.2
Créer un dossier ............................................................................................20
4.7.3
Ajouter les rapports.......................................................................................21
4.7.4
Tester et valider les rapports..........................................................................22
4.7.5
Exécution......................................................................................................23
Hibernate......................................................................................................................24
5.1
Introduction ..........................................................................................................24
5.2
Présentation d’Hibernate.......................................................................................24
5.3
Utilisation d’ Hibernate.........................................................................................25
QBE .............................................................................................................................27
6.1
Présentation ..........................................................................................................27
6.2
Paramètrage ..........................................................................................................27
6.3
Fonctionnement ....................................................................................................31
Problèmes rencontrés :..................................................................................................34
7.1
Difficultés et problèmes rencontrés .......................................................................34
7.2
Forums .................................................................................................................35
Organisation du travail .................................................................................................36
Conclusions ..................................................................................................................38
10
Annexes :..................................................................................................................39
10.1 Notice d’installation SPAGOBI ............................................................................39
10.2 Versions et liens des fichiers utiles........................................................................39
10.2.1 Documentation :............................................................................................39
10.2.2 Fichiers nécessaires au fonctionnement de SpagoBI : ....................................39
1 Introduction
1.1 Cadre du projet
Ce projet est développé pour une utilisation au sein de l’université d’Avignon.
Plusieurs bases de données sont utilisées au sein de l’université d’Avignon. Elles regroupent
des données relatives à la comptabilité, la gestion du personnel (Oracle), la scolarité et les
diplômes et maquettes (PostgreSQL).
Le besoin se fait ressentir pour un non informaticien d’obtenir des informations en
provenance de plusieurs tables simultanément.
1.2 Objectif
Nous devons mettre en place une solution pour permettre à un non informaticien de faire des
requêtes (si possible graphiquement) sur ces bases de données.
Le choix qui a été fait au 1er semestre est de mettre en œuvre une solution basée sur des
composants Open Source relatifs au domaine de la Business Intelligence.
1.3 Système existant
IL y a 2 bases de données répertoriées :Une pour la gestion du personnel (Oracle) et l’autre
pour la scolarité et les diplômes et maquettes (PostgreSQL), nommée freebo. C’est cette
dernière que nous allons utiliser.
Un serveur linux a été mis à notre disposition à l’IUP.
Nous travaillons chez nous sur un système d’exploitation Windows XP et un système MAC.
1.4 Utilisateurs
Nous devons trouver une solution pour un utilisateur novice en langage SQL.
Nous pouvons toutefois compter sur la présence de contrôleur de gestion, maîtrisant le
langage SQL.
1.5 Organisation
Un serveur Unix nous a été dédié au sein de l'IUP. Pour s'y connecter, nous disposions d'un
compte et nous y accédions par le protocole ssh. Le récupération/dépôt de fichiers s'est faite
par sftp grâce à un tunnel ssh.
C'est sur ce serveur que la base de données freebo a été installée. Afin de tester SpagoBI sur
cette base, il nous a fallu faire un « dump » de la base dont voici les principales
commandes sous postgreSQL :
a) Dumper une base :
pg_dump -D {nom_de_la_base} > {nom_du_fichier.dump}
b) Recréer une base à partir d’un dump :
psql -e {nom_de_la_base} < {nom_du_fichier.dump}
Un fichier de 800Mo a été crée à la suite de cette étape. Pour ré-injecter la base sur notre
propre machine de tests, il nous a fallu téléchargé ce fichier sur le serveur puis exécuter le
fichier dump dans notre SGBD.
1.6 Rappel sur les solutions envisagées
Au cours du 1er semestre nous nous sommes intéressé aux logiciels libres de Business
Intelligence de logiciel type Business Object (le plus connu) mais en open source :
Nous avons retenu SpagoBI et Pentaho.
Ce sont des plates-formes de Business Intelligence possédant un profil relativement similaire
en terme de fonctionnalisées.
Le fait que SpagoBI ne nécessitant aucun ajout payant pour faire fonctionner sa plate-forme
nous a fait opté pour cette solution.
2 La plate-forme SPAGOBI
2.1 Présentation
SpagoBI est une solution OpenSource pour le développement de projets de type Business
Intelligence, proposé par la société italienne Engineering Ingegneria Informatica.
Il n'y a donc pas de fonctionnalités volontairement absentes et réservées pour une version
commerciale comme c'est le cas pour Pentaho.
Cette solution offre donc une couche logicielle complète comprenant toutes les étapes de
l’intelligence décisionnelle (voir rapport 1er semestre) comme les fonctions de Reporting,
OLAP, de data mining, dashboards, QBE, collecte des données (ETL)…
SpagoBI permet un développement très flexible permettant de « mixer » l’open source avec
des solutions propriétaires.
Son grand avantage est donc sa capacité d’intégration, ce qui permet de travailler
indépendamment par briques séparées et une meilleure répartition du travail.
Son inconvénient principal est que c’est une solution jeune dans un secteur en pleine
évolution, il faut donc se tenir régulièrement au courant quant à l’ajout de nouveaux
composants et de fonctionnalités.
Site Web : http://spagobi.eng.it
2.2 Fonctionnement du Projet avec SpagoBI
Rappel : l’objectif est de permettre à l’utilisateur final de faire des requêtes graphiques sur une
base de données.
Pour cela nous découperons les phases principales du projet conformément aux étapes d’un
projet de Business Intelligence.
• La collecte de données se fera par Talend Open Studio qui est un outil d'ETL en cours
d’intégration avec la plate-forme SpagoBI.
• La préparation de la partie Reporting sera réalisée par BIRT.
• La partie modélisation par Hibernate.
• La partie requête graphique de l’utilisateur final par le SpagoBIQbeEngine
SpagoBI propose en téléchargement une version démo, celle ci propose au développeur des
« portlets », des applications qui, placées dans un portail web, servent alors de conteneurs.
Ces portlets prédéfinis qui permettent d’accéder aux fonctionnalités (reporting, QBE, etc…)
de SpagoBI. Suivant les conseils de l’équipe technique d’ IEE nous sommes donc parties de la
version démo qui offre aux nouveaux utilisateurs de SpagoBI un socle complet pour débuter
avec le produit.
2.3 Installation
SpagoBI peut fonctionner sur les plates-formes Windows et Unix (linux, MacOS X,...).
Pour fonctionner, SpagoBI requiert essentiellement trois éléments :
− Installation d'un serveur d’application sur lequel reposera la plate-forme de Business
Intelligence. Trois types de serveurs d'applications, écrits en Java sont proposés : Tomcat,
Jboss et Jonas. Pour sa stabilité et sa simplicité d'installation, nous avons opté pour
Tomcat. Le serveur doit être installé au préalable avec « exo-portal ». Produit par une
startup française « EXO Plateform », il s'agit d'un portail permettant d'inclure des
portlets.
− Installation d'une JDK.
− Installation d'OpenOffice.
Les différentes versions des fichiers concernant le serveur d'application et SpagoBI sont
téléchargeables sur le site http://forge.objectweb.org/ respectivement dans les projets eXo et
SpagoBI.
Note : Pour les noms et versions exactes des fichiers, cf 10.1 Notice d'installation de SpagoBI.
2.3.1 Installation de Tomcat avec eXo-Portal
L'installation de Tomcat avec eXo-Tomcat est simpliste. Il suffit de télécharger l'archive et de
la décompresser dans le répertoire où SpagoBI sera installé.
2.3.2 Installation de SPAGOBI
Avant le 06 avril 2007, aucun installeur graphique de SpagoBI n'existait. La démarche à
suivre en consistait en l'installation, en plus des trois éléments (Java, OpenOffice, Tomcat
avec eXo-Portal), de la « metabase de données » (Oracle, PostgreSQL, mySQL, HSQLDB)
utilisée par SpagoBI, de ses drivers, la configuration d'un JNDI (pour la connexion de
SpagoBI à sa source de données (la metabase), l'installation d'un « cms repository » (System
de management de contenu), l'installation de la plateforme SpagoBI avec des configurations
légères et enfin l'installation des moteurs souhaités (Birt, QBE,...).
Cette solution nous a posé de nombreux problèmes (de très nombreuses erreurs bloquantes
suites aux nombreuses étapes dans l'installation), c'est pourquoi nous avons opté pour
l'installateur graphique où l'on suit les étapes interactives à l'écran.
A un stade de l'installation, une liste de moteurs est proposée, nous prendrons alors soin, entre
autres, de sélectionner SpagoBirtReportEngine (cf 4. Birt) et SpagoBIQBEEngine (cf 6.
QBE).
2.4 Démarrage
Une fois SpagoBI correctement installée, la plate-forme peut être démarrée. Pour ce faire, il
est nécessaire d'exécuter le script /Spago/exo-portal/StartSpagoBI.sh ( StartSpagoBI.bat sous
Windows) qui se charge de lancer la metabase de donnée et surtout le serveur d'application.
Pour stopper l'application, il faut exécuter le script StopSpagoBI.sh.
Note : La ligne de commande détail le démarrage de l'application (ex : démarrage de chacun
des moteurs SpagoBI) et l'on peut voir une erreur qui apparaît plusieurs fois :
[ERROR] PersistentManagerBase - No Store configured, persistence disabled
Cette erreur est connue car de nombreux utilisateurs la voient mais sur le forum officiel,
l'équipe technique de SpagoBI nous a informé qu'elle était non bloquante et qu'il ne fallait pas
s'en soucier.
Une fois démarrée, SpagoBI est accessible par le biais d'un navigateur Internet à l'adresse :
http://serveur:8080/sbiportal
La première page détaille les profils sous lesquels l'utilisateur peut se connecter pour accéder
aux fonctionnalités qui lui correspondent.
Il y a 4 types d’utilisateurs de SpagoBI:
1.Administrator: gère la configuration et les aspects de sécurité.
Sous ce profil nous allons créer un répertoire pour entreposer les documents (rapports) et
définir les droits d’accès.
2.Developer: Pour créer ou modifier les documents.
En important les rapports pré générés de BIRT dans le répertoire adéquat.
3.Tester: Pour tester les documents (rapports en l’occurrence) que nous rajoutons via la
partie administrateur et développeur. Ensuite il a la possibilité de valider ou non le document.
4.User: Peut utiliser tout les documents dont la mise en exploitation a été validé par les
précédents, l’usage, l’accès et les droits des documents sont limités par les paramètres définis
précédemment.
C’est donc pour un user que nous allons concevoir les étapes suivantes afin d’aboutir sur la
partie QBE.
3 Extraction des données : Talend Open Studio
3.1 Pourquoi Talend Open Studio?
L'université d'Avignon utilise des données provenant de plusieurs bases de données (ex :
Diplômes, Scolarité), qui ne sont pas forcément implémentées au sein du même système de
gestion de base de données (ex : postgreSQL, Oracle) et des utilisateurs appartenant à
l'administration de l'université éprouvent le besoin de faire des requêtes à partir de ces
différentes bases.
Cette étape de la Business Intelligence, appelée fonction d'ETL, est présente dans notre projet
car elle permet de collecter des données provenant de plusieurs bases de données, ce qui ne
peut se faire par le simple biais de requêtes SQL.
Il s'agit bien sûr d'un travail que seul un informaticien pourra faire car il est indispensable de
connaître le langage SQL. Il pourra ainsi au préalable créer de nouvelles bases de données
répondant aux besoins précis des utilisateurs finaux.
Talend Open Studio (ou TOS) est un outil d'ETL open source, capable d’extraire des données
de différentes bases de données.
Cet outil propose une solution « clés en main », offrant un logiciel téléchargeable et
exécutable de façon autonome sur un système d'exploitation. En outre, Talend peut s'intégrer
à la plateforme SPAGOBI qui, jusqu’il y a peu, était dépourvu de solution d'outil
d'intégration de données.
Etant donné nos problèmes rencontrés lors de l'installation de SpagoBI avant la sortie de
l'installeur graphique, nous avons découvert et pris en main Talend Open Studio dans sa
version clé en main.
3.2 Présentation de Talend Open Studio
Le logiciel est téléchargeable sous forme d'une archive sur le site officiel
(http://www.talend.com/download.php), qu'il suffit de décompresser pour installer
l'application. L'outil d'ETL est, depuis quelques mois disponible dans un version écrite en
Java (qui fait suite à une version écrite en Perl), ce qui donne la possibilité au programmeur
d'ouvrir un projet TOS au sein du logiciel Eclipse. C'est cette version que nous avons choisit
d'utiliser.
Après avoir décidé de l'ouverture ou de la création d'un nouveau projet, l'application, nous
offre une apparence de style « TreeView » familière à Eclipse. On peut y voir les vues
suivantes : le référentiel (Repository), l’espace de travail (WorkSpace), les
sorties/erreurs/logs. Et l’aperçu Schéma/code.
figure 1 : Interface de Talend Open Studio
Le Repository donne accès à deux types essentiels de projet : les « Business Models » et les
« Job Design ». Le premier type permet de modéliser des processus métiers alors que celui
qui nous intéresse, le Job Design, permet lui d’associer les composants qui nous permettront
de manipuler les flux de données provenant de différentes bases.
Des liens vers ces bases doivent être configurés avant toute chose. C’est ainsi qu’il est
nécessaire d’ajouter des « connections » à l’élément « metadata/DB Connections » du
repository (clique-droit, new connection). Une connexion par base de données est nécessaire.
Les paramètres à fournir sont les suivants :
type de la base : mySQL/PostgreSQL/Oracle …
url de la connexion : sous la forme « jdbc:typeDeBase://adresse:port/baseDeDonnées
login/password : pour la connexion à la base de données
adresse du serveur du serveur de base de données
numero de port du serveur de base de données
nom de la base de données
figure 2 : Paramètres de connexion à une base de données
Nous avons décidés de tester TOS au travers d’un exemple auquel on peut être confronté dans
le cadre de notre projet, mysql sera le SGBD.
Voici trois bases de données,
datab1 :
table student : id_student (numeric), name_student (varchar)
table speciality : id_speciality (numeric), name_speciality (varchar)
table match1 : id_speciality (numeric), id_student (numeric)
datab2
table course : id_ course (numeric), name_ course (varchar)
table speciality : id_speciality (numeric), name_speciality (varchar)
table match2 : id_speciality (numeric), id_course (numeric)
datab3
table student : id_ student (numeric), name_ student (varchar)
table course : id_ course (numeric), name_ course (varchar)
table match3 : id_ student (numeric), id_course (numeric)
La base datab1 permet de savoir que tel étudiant (student) appartient à telle filiere (speciality),
grâce à la table match1. Cette base est actuellement remplit.
La base datab2 permet de savoir que tel étudiant (student) suit tel cours (course), grâce à la
table match2. Cette base est actuellement remplit.
La base datab3 permet de savoir que tel cours (course) appartient à telle filiere (speciality),
grâce à la table match3. Cette base est actuellement vide, et c’est celle-ci que nous voudrions
remplir à partir des 2 premières afin qu’elle nous fournisse les informations demandées.
Ce problème fait appel à des composants de la catégorie « database » qui vont nous permettre
d’extraire, d’assembler et d’injecter des données dans des bases suivant ces 3 étapes :
a) Extraction des données des 2 bases datab1 et datab2
Utilisation de 4 composants « tMySQLInput» pour :
- extraire la liste des étudiants à partir de datab1 (tMySQLInputDB1_student)
- extraire la liste des correspondances entre les étudiants et leur filière à partir de
datab1 (tMySQLInputDB1_match1)
- extraire la liste des cours à partir de datab2 (tMySQLInputDB2_course)
- extraire la liste des correspondances entre les cours et les étudiants à partir de
datab2 (tMySQLInputDB2_ match2)
figure 3 : Paramètres du composant tMySQLInputDB1_student
b) Multiplexage des données
Utilisation du composant central « tmap » qui permet de sélectionner les données
entrantes, les conditions et leur destination.
Paramétrage du composant tMap
Comme peut le voir sur la figure 3, le paramétrage du tMap nous propose une vue à
gauche des 4 entrées de données, correspondant au 4 tMySQLInput. Le « join » entre
les divers champs sont à définir en reliant simplement les champs concernés, d’où la
présence de traits violets sur la gauche de la fenêtre.
Ensuite, nous relions les données à extraire (id_Student et id_course) au composant
newOutput1, dont nous verrons le rôle juste après, à droite de la fenêtre de
paramétrage du tMap.
c) Injection des données dans la base vide
Il est enfin nécessaire d’injecter ces données pertinentes (id_Student et id_course) dans
la 3ème base, datab3. Ceci est fait en partie grâce au composant newOutput1 du tMap
qui est lié au composant tMysqlOutput_2 présent sur le job. Ce dernier est paramétré
pour interagir avec datab3, la base à remplir.
figure 4 : Vue complète du job
Il reste alors à démarrer le job grâce à l’icône de la flèche verte, qui doit s’exécuter avec
succès. On peut ensuite constater dans notre base de données datab3, que les champs
(id_Student et id_course) sont tous là et qu’ils correspondent. Cette base remplit donc à
présent son rôle : nous savons que tel étudiant suit tel cours.
Note : TOS bénéficie de plus d’une communauté très dynamique. De nombreuses mise à jour
sont régulièrement publiées et le forum est très actif, ce qui nous a permis de surmonter
quelques difficultés dans la prise en main du logiciel ou des bugs d’un version antécédentes
(cf 7.1 Difficultés et problèmes rencontrés).
3.3 Intégration avec SpagoBI
Il est à noter que nous avons seulement utilisé une infime partie des possibilités de TOS, en
limitant notre production à des tests pour générer une base de données à partir de plusieurs.
Une étude approfondie des bases de données « cibles » et des besoins devrait permettre une
utilisation optimisée de cette étape.
4 BIRT
4.1 Présentation
Le projet BIRT, Business Intelligence and Reporting Tools est un plug-in Eclipse opensource qui propose un système de création de rapports ( ou états ) pour les applications Web.
Il se compose d’un outil de conception de rapports basé sur Eclipse et d’un moteur
d'exécution installable dans un serveur d'applications J2EE.
L'utilisation de BIRT peut se résumer de la façon suivante :
figure 5 : Schéma de l’utilisation de BIRT
En ce qui concerne l’affichage des données. BIRT propose une vue 'Explorateur de données'
qui permet la définition d'une ou plusieurs 'sources de données' (par exemple une base de
données relationnelles) et d'un ou plusieurs 'jeux de données' extraits de la source de données
(par exemple les champs renvoyés par une requête SQL). Les 'jeux de données' constituent les
données à afficher.
L'édition du rapport se fait en mode graphique en insérant les différents composants
graphiques proposés (Texte, image, tableau, liste, graphique, ...). Les valeurs affichées par ces
composants peuvent être soit statiques, soit extraites des 'jeux de données', soit calculées en
utilisant des formules prédéfinies et des scripts écrits en JavaScript.
A tout moment, le concepteur du rapport peut demander son exécution directement à partir du
viewer de BIRT.
Il y a plusieurs choix possible pour le format de la prévisualisation :HTML ou PDF.
La mise en exploitation se fait en déployant le rapport sur un serveur d'applications J2EE dans
lequel le moteur d'exécution BIRT a été installé.
4.2 Installation
Le projet BIRT propose plusieurs téléchargements mais seul Birt version 2.0.1 fonctionne
avec le SpagoBIBirtEngine.
http://download.eclipse.org/birt/downloads/build.php?build=R-R1-2_0_1-200602221204
Il faudra donc veiller à prendre la version full comprenant la partie outil de
conception (Report Designer) et la partie moteur d'exécution (Report Engine et donc le
SpagoBIBirtEngine).
4.3 Utilisation et Intégration avec SPAGOBI
La partie BIRT est essentiellement axée pour le développeur.
Sachant que le but d'un rapport est d'afficher des données, dans notre projet nous allons
utiliser BIRT pour 2 objectifs :
• Créer quelques rapports pré générés que nous chargerons par la suite dans SpagoBI.
Ces rapports finis seront directement exécutables pour l’utilisateur dans SpagoBI.
• Dans un second temps, nous avons explorer les fonctionnalités de Birt pour faciliter la
préparation de rapport :
Nous avons la possibilité de créer un template qui est un modèle de présentation au
niveau design et/ou niveau contenu pour construire des rapports. Nous pouvons aussi
personnaliser la librairie comprenant l’ensembles des composants et des données
nécessaire pour la préparation des rapports sous Birt.
Pour ce faire nous avons d’abord suivi le tutorial pour créer un rapport afin de maîtriser l’outil
BIRT.
Puis une fois cette étape de conception maîtrisée nous avons développé les différentes étapes
qui vont constituer la création de rapports personnalisées avec la base freebo.
4.4 Création de rapports pré générés
4.4.1 Introduction
On commence par la création d’un projet Eclipse (même si BIRT ne nécessite pas la création
d'un projet Eclipse d'un type particulier un type de projet nommé 'projet d'état' est tout de
même proposé).
figure 6 : Créer un nouvel état
Puis on crée un nouveau rapport :
Nous avons ici la possibilité de sélectionner un modèle prédéfini (template) de rapport parmi
une liste.( Liste simple, groupées, rapport vierge, graphique etc…)
Nous verrons plus tard comment pour concevoir notre propre template.
Une fois crée le rapport est disponible dans la zone d'édition.
4.4.2 Créer une source et un jeu de données.
Nous allons devoir paramétré une source de données (data source) et un jeu de données (data
set) correspondant d’une part à la base de données sur laquelle nous travaillons et d’autre part
sur le contenu.
Une data source est une connexion à une base de données telle qu’une connexion JDBC.
Une data set est une description des données sur lesquelles on va travailler. Les requêtes SQL
seront le plus souvent utilisées.
4.4.2.1 Définition de la source de données
Chaque rapport est associé à un ou plusieurs jeux de données qui seront manipulés pour
définir la structure des données du rapport.
En ce qui nous concerne, nous allons par la suite utiliser des bases de données relationnelles
accessibles par JDBC découlant de TOS pour définir notre source de données.
figure 7 : Sélection du type de la nouvelle source
4.4.2.2 Extraction à partir d'une base de données
Si BIRT prend en charge la connexion à la base de données et l'extraction des données, il faut
néanmoins préciser d'une part les informations de connexion (le driver notamment): et d'autre
part la requête SQL à utiliser.
Pour ce faire dans l'assistant de création il faut indiquer les paramètres suivants : le driver
JDBC, la chaîne de connexion JDBC (sous la forme
« jdbc:typeDeBase://adresse:port/baseDeDonnées), le nom d'utilisateur et le mot de passe
(optionnel).
Figure 8 : Ajout nouvelle source de données
Nous pouvons ajouter le driver correspondant à la base dans la partie « Gérer les pilotes ».
Ainsi nous avons ajouté le driver postgreSQL que nous avons récupéré :
jdbc.postgresql.org/download.html
En ce qui concerne la base oracle on utilisera le driver : « ojdbc14.jar drive »
et pour la base mysql : « mysql-connector-java-3.1.14-bin.jar »
figure 8 : Ajout du driver
L'étape suivante consiste à créer un ou plusieurs 'jeu de données' qui seront associés à la
source de données.
4.4.2.3 Manipulation d'un jeu de données (data set)
figure 9 : Nouveau jeu de données
Une fois défini, le jeu de données apparaît dans la vue 'Exploration des données'.
L'assistant de création d'un jeu de données permet la visualisation de la structure des tables et
l'édition de la requête SQL.
Les propriétés du jeu de données sont éditables, il est notamment possible de rajouter des
champs calculés :
On va indiquer la requête SQL à utiliser.
Exemple d’un jeu de données qui est utile pour notre projet :
figure 10 : Jeu de données
Nous pourrons aussi regrouper des données provenant de différentes différents type de
DataSources (de 2 bases de données mysql et oracle par exemple) en utilisant « Join Data
Set » et créer autant de jeux de données que nécessaire.
Nous avons ainsi un ensemble de jeux de données prêt à utiliser.
figure 11 : Explorateur de données
4.4.3 Conception d'un rapport
Pour ce qui est du contenu nous pouvons maintenant utiliser l’éditeur proposé par Birt pour :
•
Choisir le composant que nous désirons insérer dans le rapport parmi les différents
types proposés par Birt : les composants permettant d'afficher les données sous forme
textuelle (Texte, tableau, liste), ou sous forme de graphiques
•
Sélection des données à afficher. Ces données peuvent provenir directement du jeu de
données ou être calculées par des fonctions javascript prédéfinies.
•
La dernière étape consiste à la présentation du rapport en personnalisant l’entête par
exemple( en ajoutant le nom d’utilisateur, Titre, date et le logo de l’université, police,
couleurs).
Nous avons maintenant conçu un rapport.
4.5 Créer une librairie
Nous avons la possibilité de créer une librairie qui pourra être importé dans n’importe quel
rapport et template BIRT afin de réduire significativement le temps de conception.
Par exemple, si des composants d’une libraire tel que le logo ou des requêtes sur la base à
travers un tableau ou une diagramme, sont utilisés de nombreuses fois au cours de la
conception de nouveaux rapports alors la librairie contiendra ces éléments et permettra une
réutilisation plus facile.
Les composants qui peuvent être ajoutés à la librairie incluent les data sources et sets, les
paramètres des rapports, les tableaux, graphes, thèmes et images…
La nouvelle librairie à une extension '.rptlibrary'.
Une fois la librairie crée et sauvegardée le développeur pourra importer la librairie pour
l’utiliser dans la conception de rapports.
Il pourra facilement inclure les composants aux rapports grâce à un simple drag-and-drop.
De même un simple import de la librairie suffira pour l’adapter au rapport utilisé.
Explications :
http://www.theserverside.com/tt/articles/article.tss?l=EclipseBRT
4.6 Créer un template de rapports
Nous allons vu que lors de la création d’un rapport nous avons le choix entre plusieurs
modèles, Birt donne la possibilité de créer nos propres modèles (template )de rapports adaptés
à nos besoins. Ce modèle proposera une structure et un design prédéfini qui facilitera le
développement ultérieur de nouveaux rapports.
figure 12 : Création d’un template
Une fois le template crée on le publie. Il sera maintenant disponible dans la liste de templates
proposés dans Birt lors de l’ajout d’un nouveau rapport.
En particulier nous avons vu comment proposer un template avec une entête adaptée (logo de
l’université).
La création de template pourra être particulièrement utile dans le cas ou nous souhaiterions
personnaliser la présentation des rapports générés par QBE dans SpagoBI. Cette
fonctionnalité étant en cours de développement nous n’avons pas pu la tester.
figure 13 : Exemple de rapport BIRT sur la base freebo
4.7 Ajouter un rapport à SpagoBI
4.7.1 Introduction
L’ajout de rapports pré générés dans Birt à SpagoBI peut être particulièrement utile pour
l’utilisateur final dans le cas ou celui ci peut disposer d’un développeur/gestionnaire de la
base pouvant lui proposer une liste de rapports adaptés à ces besoins.
Les étapes principales pour exécuter un rapport pré-généré de Birt dans SpagoBI sont :
1. Créer un répertoire pour mettre les rapports
2. Importer les rapports crées dans Birt dans ce répertoire.
3. Tester le Document valider le document (passer l’état de test à release) se logger en bidev
ou bitest. Sinon dans l’étape suivante
4. Exécuter le Document en se loggant en user staff_gen par exemple (nous avons également
ici la possibilité de valider le document)
A noter qu’une modification sur la base de données entraîne une modification de l’affiche du
rapport pré-généré dans SpagoBI.
4.7.2 Créer un dossier
Afin de pouvoir insérer les rapports et les rendre accessible il faudra créer au préalable un
répertoire dans l’arborescence de SpagoBi pour les entreposer.
Pour cela nous allons suivre les indications du paragraphe 6.2.1.F UNCTIONALITIES MANAGEMENT du
document quickstart.
De fait il conviendra de s’identifier en biadmin/biadmin pour pouvoir créer un répertoire.
Ensuite il faudra aller dans l’onglet « Document and tree management ».
figure 14 : Document and tree management
Puis sélectionner « functionnalies tree » pour apercevoir l’arbre complet.
figure 15 : Functionnalities management
Ensuite il suffira de cliquer sur une racine et de sélectionner insert pour insérer un nouveau
répertoire.
4.7.3 Ajouter les rapports
L ‘étape suivante ne nécessite pas nécessairement de changer d’identifiant mais il est conseillé
de le faire à partir du profil développeur : bidev/bidev.
Il faudra aller dans l’onglet « development Environnment » et changer la vue en arbre en
cliquant sur l’image du milieu
Puis conformément aux indications du quickstart(6.3.4.DOCUMENT CONFIGURATION), pour
importer les rapports crées dans Birt dans le répertoire de notre choix il faudra cliquer sur
l’icône « insert ».
figure 16 : Document configuration
De la on remplira les champs label/name/Engine (BirtEngine)
Puis on ira chercher le « report » ou il se trouve, et enfin on cochera dans quel répertoire on
veut le mettre.
figure 17 : Ajout du fichier de report dans SpagoBI
4.7.4 Tester et valider les rapports
Maintenant afin de vérifier si le rapport est bien exécutable, on se peut se connecter, soit on
reste connecté en biadmin, soit en bidev/bidev soit en « tester » (qui est le profil spécifique
aux tests et aux validations).
Pour tester si l’exécution marche bien et changer ensuite l’état de « development » à
« released » .
Il suffit ensuite de cliquer sur le rapport et de sélectionner « execute » pour lancer l’exécution
du rapport (à noter que selon les droits on peut changer l’état du rapport)
4.7.5 Exécution
Voilà le rapport est correctement installé sur la plate-forme SpagoBI, il ne reste plus qu’à
s’identifier en tant utilisateur (staff_gen par exemple)
Puis aller l’onglet navigation, ou l’on verra apparaître l’arbre des répertoires avec les
documents présents.
figure 18 : Navigation
On exécute le rapport sur un simple clic gauche.
figure 19 : Exemple de rapport dans SpagoBI
Sources :
Présentation et Fonctionnement de BIRT :
http://www.eclipsetotale.com/articles/BIRT.html
Par ailleurs présence de nombreux tutoriaux sur le site officiel:
http://www.eclipse.org/birt/phoenix/tutorial/
5 Hibernate
5.1 Introduction
Pour faire fonctionner QBE à partir de notre propre source de base de données il est
nécessaire définir au préalable un nouveau modèle de la base de données.
Ce modèle doit être réalisé à l’aide de Hibernate et consiste en la création d’un fichier (jar).
Ce fichier est en fait un « datamart », sorte d’entrepôt de données qui décrit la « structure » de
la base de données sur laquelle on souhaite appliquer du QBE depuis SpagoBI.
5.2 Présentation d’Hibernate
Hibernate est un plugin Eclipse qui nous permet de manipuler les données d'une base de
données relationnelle sous forme d'objet (ie un framework de mapping objet/relationnel. Ou
de persistance objet des données.).
Le fait de manipuler directement les données d'une base sous forme d'objet est beaucoup plus
pratique, cela nous permet de nous défaire de toute la couche SQL.
figure 20 : Une architecture en couche (Source : hibernate.org)
De plus, cela permet de définir clairement la limite entre la persistance et la couche métier, ce
qui se révèle très utile dans le cas d'une application trois-tiers.
Nous allons, cependant, nous intéresser à une couche plus basse d'une architecture
applicative, la couche d'accès aux données. Celle-ci permet d'interfacer le code métier avec
une source de données.
L'intérêt est de pouvoir changer de base de données en n'ayant besoin de ne modifier que la
couche d'accès.
L'utilisation de Hibernate permettra d'utiliser n'importe quelle BDD, tout en gardant le code
Java identique. Pour l'exemple ici, cela dit, nous allons nous servir de MYSQL.
Pour télécharger la dernière version d'Hibernate (3.2.0), il suffit d'aller le chercher sur
sourceforge
http://sourceforge.net/project/showfiles.php?group_id=40712&package_id=12778
5.3 Utilisation d’ Hibernate
Pour créer notre fichier datamart.jar, nous devons suivre une procédure précise. Dans Eclipse
(où Hibernate est installé), on crée tout d’abord un nouveau « projet Java ». A ce projet, on
ajoute (new) un nouveau fichier de configuration Hibernate, « hibernate.cfg.xml ». C’est ce
fichier qui prend en paramètres les données utiles pour la connexion avec la base de données
souhaitée :
figure 21 : Ajouter un fichier de configuration Hibernate
figure 22 : Configurer le fichier cfg
Type de la base : mySQL/PostgreSQL/,…
Driver de la base : exemple pour postgreSQL : org.postgreSQL.Driver
url de la connexion : sous la forme « jdbc:typeDeBase://adresse:port/baseDeDonnées
login : login pour la connexion à la base de données
password : mot de passe pour la connexion à la base de données
On prend soin de placer se fichier dans le répertoire qui contient les sources du projet.
Nous configurons la « console hibernate » associée au fichier précédent, puis nous devons
générer le code Hibernate. Cette étape permet de générer des classes (.java) pour toutes les
tables de la base de données et les fichiers de mapping xml associés que nous pouvons
apercevoir dans l’arborescence du projet au sein d’Eclipse. Il nous reste alors à exporter le
projet sous la forme d’une archive jar : datamart.jar.
figure 23 : Exporter le fichier
Le fichier est maintenant prêt à être importé dans SpagoBI.
6 QBE
6.1 Présentation
Query By Example est l’outil intégré à la plateforme SPAGOBI pour créer des requêtes à
partir d’une interface graphique. Cette fonctionnalité est importante dans notre projet car elle
va permettre à l’utilisateur final, non informaticien, d’interroger une base de données sans
connaître le langage SQL et afficher des résultats pertinents.
6.2 Paramètrage
QBE permet, au sein de SpagoBI, d’interroger une base de données au travers d’un
« datamart ». Pour ce faire, il est tout d’abord nécessaire de modifier des fichiers de
configuration de la plateforme de Business Intelligence pour renseigner la présence d’une
nouvelle connexion à un base de donnée au travers de QBE. Il faut ainsi modifier les 5 fichier
xml suivants (« exo-home » signifie le répertoire désignant le serveur Tomcat avec exoportal).
a) Dans exo-home/conf/server.xml, on indique les paramètres de définition d’une
nouvelle source de données comme une ressource d’application d’un serveur JNDI. Il
convient de rajouter ces lignes à l’intérieur de la balise <GlobalNamingResources> :
<Resource name="jdbc/sbifoodmart2" auth="Container"
type="javax.sql.DataSource"/>
<ResourceParams name="jdbc/sbifoodmart2">
<parameter>
<name>factory</name>
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<parameter>
<name>driverClassName</name>
<value>org.postgresql.Driver</value>
</parameter>
<parameter>
<name>url</name>
<value>jdbc:postgresql://localhost:5432/freebo</value>
</parameter>
<parameter>
<name>username</name>
<value>freebo</value>
</parameter>
<parameter>
<name>password</name>
<value>freebopass</value>
</parameter>
<parameter>
<name>maxActive</name>
<value>20</value>
</parameter>
<parameter>
<name>maxIdle</name>
<value>10</value>
</parameter>
<parameter>
<name>maxWait</name>
<value>-1</value>
</parameter>
</ResourceParams>
où jdbc/sbifoodmart2 est le nom de la ressource JNDI (le choix de ce nom vient du fait
que la ressource JNDI de démonstration était nommée jdbc/sbifoodmart)..
b) Dans exo-home/conf/catalina/localhost/SpagoBIQbeEngine.xml, on indique au moteur
QBE l’existence d’une nouvelle source de données en remplaçant la ligne désignant
l’ancienne par celle désignant la nouvelle :
<ResourceLink name="jdbc/sbifoodmart2" type="javax.sql.DataSource"
global="jdbc/sbifoodmart2"/>
à l’intérieur de la balise contexte.
c) On ajoute cette même ligne dans le fichier
exo-home/conf/catalina/localhost/spagoBI.xml
d) Dans
exo-home/webapps/SpagoBIQbeEngine/WEB-INF/conf/data_access.xml, on associe le nom
de la source de donnée (« jdbc/sbifoodmart2 ») à un nom que l’on a choisi : « Foodmart2 » (le
choix de ce nom vient du fait que la source de donnée de démonstration était nommée
Foodmart).
e) Enfin, dans le fichier exo-home/webapps/SpagoBIQbeEngine/WEB-INF/web.xml, on
ajoute ces 4 ligne dans la balise <Webapp> :
<resource-ref>
<description>Foodmart2 db</description>
<res-ref-name>jdbc/sbifoodmart2</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
Les fichiers de configuration modifiés, il faut maintenant importer et déployer le datamart au
sein de la plateforme de Business Intelligence.
Pour ce faire, il est nécessaire de démarrer SpagoBI et d’aller sur la page du moteur de QBE
par le navigateur à l’adresse http://localhost:8080/SpagoBIQbeEngine/ .
figure 24 : Page d’accueil du moteur QBE de SpagoBI
Après avoir cliqué sur le logo, il est nécessaire de se logger en tant qu’administrateur de
SpagoQBEEngine.
Ces administrateurs et leur mot de passe sont définis dans le fichier
exo-home/webapps/SpagoBIQbeEngine/WEB-INF/conf/autorization.xml
Il est à noter que les mots de passes sont cryptés dans ce fichier. Pour les générer, Engineering
Ingegneria Informatica a prévu un utilitaire (QbeEnginePasswordGenerator.sh sous Unix,
QbeEnginePasswordGenerator.bat sous Windows) à télécharger à cette adresse :
http://forge.objectweb.org/project/download.php?group_id=204&file_id=7921
Voici son interface, très simple :
figure 25 : Interface du générateur de SpagoBIQbeEngine
Il est à noté que le script .bat ne fonctionne pas sous Windows mais uniquement sous unix
avec une erreur non bloquante lors de son lancement.
Maintenant loggé en administrateur, nous pouvons charger notre datamart, en lui donnant un
nom logique qui correspond à celui de l’argument « name » de la balise « connection »
ajoutée dans le fichier
exo-home/webapps/SpagoBIQbeEngine/WEB-INF/conf/data_access.xml.
et en allant le chercher sur le disque à l’aide du bouton parcourir :
figure 26 : Chargement du datamart dans SpagoBIQbeEngine
Une fois cette étape effectuée, le datamart « Foodmart2 » apparaît en haut de l’écran :
figure 27 : Ajout du datamart dans SpagoBIQbeEngine
Le datamart peut donc être lancé depuis cette page. Pour cela, il convient de cliquer sur son
icône correspondante représentant un loupe (la crois sert à supprimer le datamart).
Il nous est alors demandé le « dialect » de la source de donnée (mySQL, postgreSQL,
Oracle,…)
figure 28 : Sélection du dialect du nouveau datamart
Un clique sur la disquette et l’on peut faire des requêtes graphiques sur notre base de données.
6.3 Fonctionnement
L’interface QBE se présente ainsi :
figure 29 : Interface du moteur de QBE
On aperçoit toutes les tables (qui rentrent dans la fenêtre) de notre base de données « freebo »,
qui laissent apparaître leurs champs lorsqu’elles sont cliquées.
Cette première étape est appelée « Field Selection » comme l’indique l’onglet (haut de la
page » sélectionné.
On trouve ensuite des étapes facultatives dans l’interrogation de la base :
conditions : conditions sur les champs de données sélectionnés.
Ordering : pour classer ses résultats
Grouping : pour les grouper
View Query : pour voir la requête SQL générée par le moteur
Save Query : pour la sauvegarder
Ensuite, l’étape obligatoire : Execute Query pour générer les résultats associés à la requête de
l’utilisateur.
Ceux-ci s’affichent alors à l’écran :
figure 30 : Affichage des résultats d’une requête QBE
Ici on affiche toutes les filières de la base dont le type est « iut ».
Comme on peut le voir, il est possible de les exporter sous plusieurs formats « connus » tels
que pdf, xls, xml,…
La démonstration que nous venons de voir s’effectue depuis la page du moteur QBE de
SpagoBI et sous le login d’un administrateur QBE.
Ce paraît évident, c’est qu’un utilisateur lambda puisse effectuer une telle opération depuis
l’interface principale de SpagoBI et sous son login ou du moins un appartenant au type
« utilisateur » (« Users »).
Pour ce faire, il est nécessaire de définir un document de « type datamart » au sein de
SpagoBI.
Une fois connecté sur SPAGOBI en biadmin / biadmin (profil « technicien»), il faut aller sur
l’onglet « document and tree management », sélectionner les documents de type « QBE »,
montrer les templates en cliquant sur « Show document templates ». Les différents templates
s’affiche, il convient alors de télécharger celui à modifier. C’est dans ce fichier xml que l’on
remplacera les lignes existantes par celle-ci :
<QBE>
<DATASOURCE name="Foodmart2"
dialect="org.hibernate.dialect.PostgreSQLDialect" />
<DATAMART
name="Foodmart2"/>
</QBE>
en rapport avec le nouveau datamart à « exploiter ».
Il faut à présent charger ce fichier modifié grâce au bouton « parcourir », puis sauvegarder.
figure 31 : Interface de modification des templates QBE
Ainsi, un utilisateur (et non un technicien), loggé sous staff_gen/staff_gen peut accéder aux
fonctionnalité du moteur QBE depuis l’interface principale de SpagoBI.
figure 32 : Aperçu de l’Interface Utilisateur du moteur QBE dans SpagoBI
7 Problèmes rencontrés :
7.1 Difficultés et problèmes rencontrés
- L’installation « manuelle » de SpagoBI en ligne de commandes nous a posé des
problèmes sur les différents systèmes sur lesquels nous avons essayé : Windows XP,
Linux et Mac OS souvent avec des erreurs différentes. Heureusement, en avril 2007,
Engineering Ingegneria Informatica proposait un installeur graphique de la plate-forme
Open Source.
- Nous avons parlé de nos difficultés à faire des requêtes graphiques au sein de
SpagoBI (QBE) sur la base de données que M. Spriet a installé sur notre serveur à l'IUP.
La taille de la base de données à manipuler étant conséquente (800 Mo), cela a entraîné
une portabilité délicate et des temps de chargement assez long pendant la manipulation.
L’encodage des caractères du fichier de Dump de la base a également du être modifié.
Nous avons du procéder sur des bases d ‘exemples de nos crues pour toutes les phases de
tests et d’apprentissages.
- Pour installer la base de donnée sur une machine Windows, il est nécessaire que le
disque soit partitionné en NTFS, ce qui exclu les autres modes.
- Talend Open Studio a posé un problème bloquant sur un composant (tmap), ce que
nous avons signalé sur le forum officiel. Il s’agissait d’un bug reconnu par l’équipe de
développement, il nous a fallu changé de version de logiciel (lien sur le forum :
http://www.talendforge.org/forum/viewtopic.php?id=476) pour passer de la M3 à la RC1.
- Trouver les bonnes versions des solutions intégrées à SpagoBI, par exemple
SpagoBIBirtEngine ne tourne qu’avec Birt version 2.0.1. et cela n’est pas indiqué
implicitement.
- La solution étant jeune et en pleine évolution, les points manquants et défaillants sont
encore nombreux et en cours de résolutions.
- De plus la communauté Internet étant peu développée et très peu active, les cas de
blocage furent nombreux et mirent du temps à se résoudre.
-
Difficulté évidente à « s’auto former ».
- La réalisation de ce fichier pour la base de donnée du projet freebo, nous a engendré 8
erreurs pour huit classes distinctes. Il a donc fallu supprimer ces classes (ainsi que les
fichiers de mapping xml associés) du projet pour pouvoir créer le .jar. Dans le cas
contraire, le .jar que l’on importe dans SpagoBI génère une erreur bloquante qui affiche les
deux caractères ‘]>’ au sein de la page web en lieu et place des tables et champs de la base
de données.
7.2 Forums
Voici les sujets que nous avons crée où dont nous avons participé dans différents forums:
- Forum officiel de SpagoBI (http://forge.objectweb.org/forum/?group_id=204) :
Sujet : « Problem with the jndi server definition »
http://forge.objectweb.org/forum/forum.php?thread_id=3448&forum_id=862
Sujet : « how to change the QBE datasource »
http://forge.objectweb.org/forum/forum.php?thread_id=3402&forum_id=862
Note : ce sujet est resté sans réponse.
Sujet : « Errors when launching spagoBI »
http://forge.objectweb.org/forum/forum.php?thread_id=3354&forum_id=862
- Forum officiel de Talend Open Studio (http://www.talendforge.org/forum/) :
Sujet : « How to connect 2 databases »
http://www.talendforge.org/forum/viewtopic.php?id=406
Sujet : « DBConnection problem »
http://www.talendforge.org/forum/viewtopic.php?id=429
Sujet : « tmap editor error »
http://www.talendforge.org/forum/viewtopic.php?id=476
Sujet : « A beginning error with DBConnections »
http://www.talendforge.org/forum/viewtopic.php?id=475
- Forum de Hardware.fr (http://forum.hardware.fr/)
Sujet : « Problème d'encodage de caractères »
http://forum.hardware.fr/hfr/OSAlternatifs/Codes-scripts/probleme-encodage-caracteresujet_63206_1.htm
Note : ce sujet fait suite au problème d’encodage du fichier dump de la base freebo.
- Forum de Developpez.com (http://www.developpez.net/forums/)
Sujet : « Comment installer birt sous MacOs X »
http://www.developpez.net/forums/showthread.php?p=2067015#post2067015
Sujet : « Hibernate et le QBE »
http://www.developpez.net/forums/showthread.php?p=1953381#post1953381
Sujet : « [SpagoBI] Recherche de documentation »
http://www.developpez.net/forums/showthread.php?p=1953122#post1953122
Sujet : « Si qqun connait spagoBI »
http://www.developpez.net/forums/showthread.php?p=1952741#post1952741
Sujet : « Recherche ETL pour SPAGOBI »
http://www.developpez.net/forums/showthread.php?t=283818
8 Organisation du travail
•
Semaines du 21 janvier au 5 février
o Analyse comparative technique des solutions SpagoBI et Pentaho
7 février :
o Choix de la solution avec monsieur Spriet
Semaine du 12 au 18
o Proposition de planning
o Prévision pilotage
o Développement de la Page Web du projet.
Semaine du 19 au 25 février
o Installation Tomcat et java JDK à nos domiciles.
o Recherche d’informations pour le choix de l’ETL, l’outil d’extraction de bases
de données (la partie principale de notre projet)
o Entre Kettle (le plus répandu) et Talend Open Studio (en voie d’intégration
avec la plate-forme SpagoBI) nous avions d’abord pensé utiliser Kettle,
puisque Kettle marche avec du java et Talend Open Studio avec du Perl.
o Mais le 28 février, nous avons appris que Talend Open Studio venait de sortir
une version qui supporte java. Donc le choix de l’ETL s’est porté sur Talend
Open Studio.
•
Semaine du 25 au 4 Mars
o Installation Tomcat et SpagoBI à nos domiciles
•
Semaines du 4 Mars au 6 Avril
o Tentatives d'installation d'eXo-Tomcat pour SpagoBI sur le serveur de l'IUP.
o Prise en main de Talend Open Studio (outil d'ETL) et de Birt (générateur de
rapport).
•
Semaines du 10 Avril au 11 mai
o Prise en main de Birt pour la création de « reports » sur des données
implémentées au sein d'un SGBD (postgreSQL dans notre cas) d’exemples
personnalisés.
o Tests pour le fonctionnement de la partie « qbe » (Query by example) de
SpagoBI pour pouvoir faire des requêtes graphiques en ligne sur une base
postgreSQL.
o Installation et prise en main d'Hibernate (plugin Eclipse de framework de
mapping objet/relationnel)
o Conception d’un datamart nécessaire pour le fonctionnement de SPAGOBI sur
notre base de données.
•
Semaines du 12 Mai au 28 Mai
•
•
•
o Essais pour faire fonctionner le « qbe » sur la base de données de M Spriet se
trouvant sur Harry (nécessité de faire un « dump » de la base).
o Développement final du site Web du projet.
o Essais pour pouvoir présenter au sein de SpagoBI des rapports concernant la
base de données de M Spriet.
o Création de templates et de « reports » avec BIRT sur des données
implémentées au sein de la base de données fournie (postgreSQL dans notre
cas).
o Ajout de ces « reports » dans SPAGOBI (test sous XP et MacOS X).
o Facultatif : installation de SpagoBI sur le serveur de l'IUP avec Talend Open
Studio et BIRT (nécessité de l'installation d'un serveur X sur le serveur).
9 Conclusions
Le domaine de la Business Intelligence regroupe des fonctionnalités très demandées dans le
domaine de l’informatique. Les outils de ce type sont complexes, lourd à mettre en place et le
plus souvent payants. Mais depuis quelques temps, certains logiciels, à l’image de SpagoBI,
proposent des solutions open source et gratuites. Ces produits sont encore jeunes mais tout à
fait utilisables et évoluent à grands pas.
La découverte, l’installation et l’utilisation de SpagoBI nous a permis de voir qu’il était
possible de remplir l’objectif de notre projet à travers cette solution. Une fois installée et
configurée, cette plate-forme de Business Intelligence nous a prouvé qu’à travers celle-ci,
nous pouvions créer des groupes d’utilisateurs, interroger n’importe quelle base de données
graphiquement et dresser des rapports prédéfinis sur les données qui évoluent au sein de la
base.
Ainsi, les utilisateurs non-informaticiens peuvent accéder en ligne comme ils l’entendent aux
données dispersées dans le système d’informations et les mettre en forme pour les exploiter.
Ce rapport présentes toutes les marches à suivre pour
- installer et paramétrer SpagoBI
- extraire des informations à partir de plusieurs bases de données (ETL)
- définir de nouvelles connexions vers dans nouvelles bases de données pour pouvoir les
interroger graphiquement en ligne au sein de SpagoBI (Hibernate, QBE)
- définir des rapports prédéfinis, intégrés dans SpagoBI qui évoluent avec les données
physiquement implémentées (BIRT)
Nous avons du faire face à la complexité et la taille de la solution à développer.
Malgré le fait que nous nous intéressions seulement à la partie création graphique de rapports,
nous avons conclu qu’il était indispensable d’aborder les différentes étapes d’un projet de
Business Intelligence pour pouvoir exécuter le QBE.
Cela a entraîné des contraintes de temps d’apprentissage conséquent qui ont fait qu’au niveau
de l'organisation et de la gestion du projet nous avons du passer par une longue phase
d’apprentissage en parallèle pour comprendre les concepts fondamentaux de la solution.
Par ailleurs, parmi les orientations qui peuvent être envisagées :
SpagoBI donne la possibilité d’utiliser le scheduler intégré à TOS afin d’automatiser l’accès
aux bases de données.
Une étude des besoins de l’utilisateur devrait permettre l’optimisation de l’exploitation de la
base de données pour explorer les possibilités qu’offrent TOS et pour spécifier son
intégration.
De même pour construire une librairie Birt et des templates (que nous avons mentionné
précédemment).
Concernant la définition des utilisateurs, nous avons la possibilité de créer de façon complète
et détaillée des groupes d’utilisateurs afin d’adapter clairement les accès aux besoins des
utilisateurs. Et ainsi fournir un schéma complet des utilisateurs.
Une plate-forme libre de Business Intelligence peut difficilement se réduire à du QBE et du
reporting et l’on peut très bien imaginer à terme remplacer une solution propriétaire. Ce qui
s’avère fortement intéressant et mérite d’être étudié plus largement.
10 Annexes :
10.1 Notice d’installation SPAGOBI
Il est recommandé d’installer d’abord Tomcat avec exo-Portal, puis l’installation graphique de
SpagoBI.
Ensuite les installations de Birt, Hibernate ( plug-ins Eclipse ) et Talend Open Studio.
Toutes les sources et les notices se trouvent dans les liens suivants.
10.2 Versions et liens des fichiers utiles
10.2.1
Documentation :
Installation Graphique : HowToUseSpagoBIInstaller--1.9.2.pdf
http://forge.objectweb.org/project/download.php?group_id=204&file_id=7927
Installation manuelle : SpagoBI_eXoTomcat_Installation_Manual_1.4.3.pdf.zip
http://forge.objectweb.org/project/download.php?group_id=204&file_id=7704
Configurer SpagoBI : SpagoBI_How_To-1.6.pdf
http://forge.objectweb.org/project/download.php?group_id=204&file_id=7661
Pour débuter avec SpagoBI : QuickStart-0.9.2.pdf.zip
http://forge.objectweb.org/project/download.php?group_id=204&file_id=7660
Petite aide visuelle pour SpagoBI : petite_aide_visuelle_spagobi.pdf
http://www.altic.org/actualite/98.shtml
Livret blanc de Talend Open Studio (Installation et prise main):
Documentation sur BIRT (site officiel) :
http://www.eclipse.org/birt/phoenix/
Documentation BIRT (site référence français) :
http://www.eclipsetotale.com/articles/BIRT.html
10.2.2
Fichiers nécessaires au fonctionnement de SpagoBI :
- exo-portal-1.1.4-tomcat.zip
http://forge.objectweb.org/project/download.php?group_id=151&file_id=8171
- Espace de téléchargement de SpagoBI et de ses moteurs :
http://forge.objectweb.org/project/showfiles.php?group_id=204
- SpagoBIInstaller-1.9.2-04062007.zip
http://forge.objectweb.org/project/download.php?group_id=204&file_id=7970
- SpagoBIQbeEngine-bin-1.9.2-03302007.zip
http://forge.objectweb.org/project/download.php?group_id=204&file_id=7921
- OpenOffice :
http://download.openoffice.org/index.html
- JDK :
http://developers.sun.com/downloads/
- Birt 2.0.1
http://download.eclipse.org/birt/downloads/build.php?build=R-R1-2_0_1-200602221204
Note : Nous vous conseillons de prendre birt-report-designer-all-in-one-2_0_1.
- Eclipse
http://www.eclipse.org/downloads/download.php?file=/eclipse/downloads/drops/R-3.2.2200702121330/eclipse-SDK-3.2.2-macosx-carbon.tar.gz
- Hibernate (JBossIDE-1.5-ALL.zip à dézipper)
http://sourceforge.net/project/showfiles.php?group_id=22866&package_id=72248&release_i
d=382687