Vieira Julien

publicité
Vieira Julien
Castelein Maxime
IMA2i
Avant Projet
GLOBUS/GGM
Responsable : N. Melab
Année 2004/2005
SOMMAIRE
Introduction : ........................................................................................................................... 3
1) Présentation générale du projet GGM .......................................................................... 4
11) Définition de la grille géno médicale ........................................................................ 4
12) Le grid computing ..................................................................................................... 5
13) les responsables du projet : ....................................................................................... 6
2) Solutions ........................................................................................................................... 6
21) Le concept de réseaux virtuels : Principe et fonctionnement ................................ 6
22) Le réseau RENATER ................................................................................................ 8
23) Vtun............................................................................................................................. 9
231) Contexte et objectif .............................................................................................. 9
232) Architecture de la grille .................................................................................... 10
a) Aperçu global ..................................................................................................... 10
b) Architecture détaillée ........................................................................................ 10
233) Plan d’adressage ................................................................................................ 11
24) Globus ....................................................................................................................... 13
241) Présentation de Globus ..................................................................................... 13
242) Globus ................................................................................................................. 14
243) Déploiement d’un service .................................................................................. 15
244) Web Services ...................................................................................................... 15
245) Créer un fichier GAR avec ANT ...................................................................... 16
3) Résultats: ........................................................................................................................ 17
31) Choix de l’environnement de travail ..................................................................... 17
311) Choix du système d’exploitation (OS) ............................................................. 17
312) Choix de la version de Globus .......................................................................... 18
32) Installation de Globus ............................................................................................. 18
321) Logiciels pré requis ............................................................................................ 18
322) Configuration de Globus ................................................................................... 19
323) Déploiement d’une application simple ............................................................. 19
33) Mise en œuvre logicielle du VPN ............................................................................ 20
331) Installation de VTUN ........................................................................................ 20
332) Autorisation d’accès à Internet ........................................................................ 21
333) Création et activation des tunnels .................................................................... 21
Conclusion: ............................................................................................................................. 23
ANNEXES .............................................................................................................................. 24
1) Déploiement d’une application : Fichiers exemples ............................................... 24
2) Logiciels requis .......................................................................................................... 30
3) Globus toolkit :........................................................................................................... 34
4) Test Globus ................................................................................................................. 35
2
Introduction :
Cet avant projet rentre dans le cadre du projet national Grille Geno Médicale (GGM)
regroupant trois laboratoires de recherche en informatique, à savoir LIFL (Lille), LIRIS
(Lyon) et l'IRIT (Toulouse). Ce projet vise à proposer une architecture logicielle s'appuyant
sur les grilles de calculs, capables de gérer des données hétérogènes et dynamiques au sein
d'entrepôts de données distribuées, à des fins d'analyse et de traitement intensifs de données
géno-médicales.
3
1) Présentation générale du projet GGM
11) Définition de la grille géno médicale
Une Grille Géno-Médicale est basée sur une architecture pour la gestion et l'analyse de
données géno-médicales sur une grille de calcul.
Les grilles de calcul ont connu un fort développement ces 5 dernières années. Des
financements conséquents ont été consentis pour faire émerger des infrastructures de grilles
de calcul fonctionnelles. Si les travaux sur les intergiciels (middleware) permettant d'utiliser
la grille pour des besoins de calcul commencent à donner des résultats positifs, le travail reste
entier, ou presque, pour la gestion et l'analyse des données partagées sur la grille.
Ce projet vise ainsi à proposer une architecture logicielle s'appuyant sur les grilles de calcul
capable de gérer des données hétérogènes et dynamiques au sein d'entrepôts de données
distribués, à des fins d'analyse et de traitement intensifs.
Ce challenge est particulièrement important dans le cadre des grilles biomédicales. En effet,
la diffusion des technologies haut débit en génomique et la gestion informatique du dossier
médical réparti ouvrent des perspectives diagnostiques totalement novatrices.
Parce qu'elles exigent une capacité d'analyse et de traitement considérable et un partage
d'informations hétérogènes et très volumineuses à grande échelle, ces technologies
apparaissent comme des " cibles " naturelles des grilles de calcul. Or, aucun des outils
nécessaires à leur mise en oeuvre effective n'existe actuellement :
1) les entrepôts de données n'ont pas encore été déployés sur grille de calcul,
et des
problèmes multiples de gestion de données dans ce contexte (hétérogénéité, dynamicité,
sécurité, traçabilité, efficacité d'accès) devront être résolus;
2) le portage efficace sur grille de calcul des algorithmes d'extraction de connaissances
(datamining) doit être généralisé à des masses importantes de données dynamiques et
hétérogènes réparties à grande échelle ;
4
3) des mandataires (proxys) sémantiques doivent être développés pour optimiser l'utilisation
des ressources (calcul, stockage) et assurer une adaptation des données aux droits et besoins
des utilisateurs finaux.
Le but du projet GGM est d'étudier ces problématiques en les intégrant dans un cadre logiciel
cohérent. Les travaux des équipes participant au projet, ainsi que les travaux classiques de la
littérature, seront adaptés à la nature des données manipulées dans ce projet.
Au-delà du domaine médical, ces problématiques se situent au coeur de l'ouverture des grilles
de calcul vers la gestion de communautés et d'organisation virtuelles et en conditionnent le
déploiement. Par la complexité des données et des processus impliqués, l'analyse génomédicale et le diagnostic intégré constituent des champs d'application particulièrement
pertinents en terme scientifique comme en terme d'impact socio-économique.
12) Le grid computing
Le grid computing, également appelé calcul partagé ou calcul distribué, consiste à exploiter
pleinement les ressources de l'intégralité d'un parc informatique (serveurs et PC) afin de
réaliser rapidement des calculs complexes qui prendraient plusieurs mois voire plusieurs
années avec des supercalculateurs classiques.
Cette idée de mutualisation des ressources informatiques est née dans le milieu de la
recherche scientifique où depuis quelques années, les besoins de puissance de calcul et de
traitement des données augmentent démesurément. Cette augmentation se produit alors que le
prix des supercalculateurs continue de grimper au point de rendre leur achat trop onéreux
pour de nombreux laboratoires.
C'est en voulant faire des économies que les chercheurs ont décidé d'exploiter ces ressources
informatiques délaissées. Ils se sont alors aperçus qu'ils "étaient capables de traiter
pratiquement 240 GigaFLOPS (le GigaFLOP correspond à 1 milliard d'opérations en virgule
flottante par seconde), soit l'équivalent de quatre serveurs Sun Entreprise 10000, en reliant en
interne, "2000 ' vieux ' PC de type Pentium cadencés à 166Mhz et une centaine de Pentium
III à 4 Ghz, ".
5
A partir de ces expériences, il est ensuite devenu possible, de relier, via internet, "des
équipements géographiquement dispersés et de constituer un réseau qui cumule les capacités
de calcul, de stockages, etc, de tous ses membres. Chacun de ceux-ci pouvant alors disposer
de la somme des ressources - puissance, mémoire, logiciels, données - apportées par tous les
autres participants du réseau" alors que les performances propres de leur micro ne dépassaient
pas celles du marché.
Cette mutualisation des ressources informatiques a pris le nom de grid computing en
référence au "power grid" (réseau de distribution de l'électricité). Le grid computing
fonctionne en effet comme un réseau électrique dans la mesure où le consommateur se fournit
sans se préoccuper de savoir où et par qui est produite l'énergie. Par extension, on parle
également de grille de calcul, de grille de données ou de grille informatique.
13) les responsables du projet :
Les équipes partenaires du projet (LIRIS, IRIT, LIFL), très complémentaires, sont fortement
impliquées dans des initiatives en grid computing, fouille de données, algorithmique
parallèle, systèmes d'information et entrepôts médicaux.
La validation de nos travaux et l'alimentation en données de nos plates-formes de test
s'appuieront sur les équipes biomédicales avec lesquelles nous entretenons des relations
étroites et anciennes (Génopoles de Lille et Lyon, Hospices Civils de Lyon).
2) Solutions
21) Le concept de réseaux virtuels : Principe et fonctionnement
Les réseaux locaux d'entreprise (LAN ou RLE) sont des réseaux internes à une organisation,
c'est-à-dire que les liaisons entre machines appartiennent à l'organisation. Ces réseaux sont de
plus en plus souvent reliés à Internet par l'intermédiaire d'équipements d'interconnexion. Il
arrive ainsi souvent que des entreprises éprouvent le besoin de communiquer avec des
filiales, des clients ou même du personnel géographiquement éloignées via internet.
6
Pour autant, les données transmises sur Internet sont beaucoup plus vulnérables que
lorsqu'elles circulent sur un réseau interne à une organisation car le chemin emprunté n'est
pas défini à l'avance, ce qui signifie que les données empruntent une infrastructure réseau
publique appartenant à différents opérateurs. Ainsi il n'est pas impossible que sur le chemin
parcouru, le réseau soit écouté par un utilisateur indiscret ou même détourné. Il n'est donc pas
concevable de transmettre dans de telles conditions des informations sensibles pour
l'organisation ou l'entreprise.
La première solution pour répondre à ce besoin de communication sécurisé consiste à relier
les réseaux distants à l'aide de liaisons spécialisées. Toutefois la plupart des entreprises ne
peuvent pas se permettre de relier deux réseaux locaux distants par une ligne spécialisée, il
est parfois nécessaire d'utiliser Internet comme support de transmission.
Un bon compromis consiste à utiliser Internet comme support de transmission en utilisant un
protocole d'"encapsulation" (en anglais tunneling), c'est-à-dire encapsulant les données à
transmettre de façon chiffrée. On parle alors de réseau privé virtuel (noté RPV ou VPN, pour
Virtual Private Network) pour désigner le réseau ainsi artificiellement créé. Ce réseau est dit
virtuel car il relie deux réseaux "physiques" (réseaux locaux) par une liaison non fiable
(Internet), et privé car seuls les ordinateurs des réseaux locaux de part et d'autre du VPN
peuvent "voir" les données.
Le système de VPN permet donc d'obtenir une liaison sécurisée à moindre coût, si ce n'est la
mise en oeuvre des équipements terminaux. En contrepartie il ne permet pas d'assurer une
qualité de service comparable à une ligne louée dans la mesure où le réseau physique est
public et donc non garanti.
En définitive, un réseau privé virtuel repose sur un protocole, appelé protocole de
tunnelisation (tunneling), c'est-à-dire un protocole permettant aux données passant d'une
extrémité du VPN à l'autre d'être sécurisées par des algorithmes de cryptographie.
7
Le terme de "tunnel" est utilisé pour symboliser le fait qu'entre l'entrée et la sortie du VPN les
données sont chiffrées (cryptées) et donc incompréhensible pour toute personne située entre
les deux extrémités du VPN, comme si les données passaient dans un tunnel. Dans le cas d'un
VPN établi entre deux machines, on appelle client VPN l'élément permettant de chiffrer et de
déchiffrer les données du côté utilisateur (client) et serveur VPN (ou plus généralement
serveur d'accès distant) l'élément chiffrant et déchiffrant les données du côté de
l'organisation.
De cette façon, lorsqu'un utilisateur nécessite d'accéder au réseau privé virtuel, sa requête va
être transmise en clair au système passerelle, qui va se connecter au réseau distant par
l'intermédiaire d'une infrastructure de réseau public, puis va transmettre la requête de façon
chiffrée. L'ordinateur distant va alors fournir les données au serveur VPN de son réseau local
qui va transmettre la réponse de façon chiffrée. A réception sur le client VPN de l'utilisateur,
les données seront déchiffrées, puis transmises à l'utilisateur.
22) Le réseau RENATER
Aujourd'hui plus de 600 établissements ayant une activité dans les domaines de la Recherche,
la Technologie, l'Enseignement et la Culture sont raccordés à RENATER. Ce réseau leur
permet de communiquer entre eux, d'accéder aux centres de recherche, aux établissements
d'enseignement du monde entier et à l'Internet.
De plus, par l'intermédiaire des rectorats, la plupart des lycées et collèges bénéficient
également du réseau.
8
Le réseau RENATER est composé d'une infrastructure métropolitaine et de liaisons
internationales à haut débit. RENATER est également présent dans les départements et
territoires d'Outre Mer.
La troisième génération du réseau appelée RENATER 3 qui utilise largement les technologies
optiques de multiplexage (DWDM), est essentiellement maillée et fédère par des liaisons à
2,5 Gbit/s les réseaux de collecte régionaux développés avec le soutien des collectivités
territoriales.
RENATER est interconnecté à 10 Gbit/s aux autres réseaux de recherche européens et
américains - y compris l'Internet 2 (réseau ABILENE) - via le réseau européen GÉANT qui
est, au plan mondial, la plus grande structure de ce type.
23) Vtun
VTun est la manière la plus simple de créer des tunnels virtuels sur des réseaux classiques
TCP/IP. Il supporte des types de tunnels différents et variés et propose plusieurs
caractéristiques utiles:
- Cryptage
- Compression
- Adaptation au trafic
VTun est facilement configurable. Il peut être utilisé pour certaines tâches réseau:
- VPN
- Mobile IP
- etc.
231) Contexte et objectif
L’objectif de ce document est d’expliquer la démarche méthodologique de mise en place
d’une petite grille dans le cadre du projet Grille Géno-Médicale (GGM) de l’ACI « Masse de
données ». Cette grille consiste en un réseau privé virtuel entre les trois sites impliqués dans
ce projet, c'est-à-dire Lille, Lyon et Toulouse. Les utilisateurs des trois sites doivent pouvoir
9
accéder de n’importe quel site et de manière sécurisée à toutes les machines de la grille quel
que soit leur localisation.
232) Architecture de la grille
a) Aperçu global
La figure ci-dessous illustre une vue globale de la grille. Celle-ci est constituée de trois
réseaux privés interconnectés par le réseau haut débit RENATER. La technologie de mise en
place de l’interconnexion est VTUN. Dans cette technologie, chaque paire de sites est
interconnectée par un tunnel. Les extrémités de chaque tunnel sont identifiées par des
nombres entiers désignant les numéros de départements, c'est-à-dire 59 du côté de Lille, 69
du côté de Lyon et 31 du côté de Toulouse.
Vue globale du VPN
Réseau privé
59-69
59-31
Réseau privé
31-69
Réseau privé
b) Architecture détaillée
La figure ci-dessous illustre l’architecture détaillée de la grille. Sur la figure, seul de nœud de
Lille est détaillé mais les deux autres sites ont une architecture similaire. Les tunnels de Lille
passent par le réseau du Campus de l’Université de Lille1 et le réseau régional NOROPALE.
Chaque réseau privé, constituant un nœud de la grille, contient une machine faisant office de
passerelle, une machine jouant le rôle de serveur NFS et de serveur NIS et au moins une
machine de calcul et/ou stockage de données.
10
La passerelle doit posséder au moins deux cartes réseau : une carte servant d’interface
d’accès au réseau public et notamment aux deux autres sites, et une interface d’accès au
réseau privé local.
233) Plan d’adressage
Le plan d’adressage est défini sur chaque site par : l’adressage du réseau privé, l’adressage
des extrémités des tunnels, et l’adresse de la passerelle.
Les
machines
du
réseau
privé
ont
une
adresse
IP
de
la
forme
192.168.<Numero_Département>.x, où x est un entier compris entre 1 et 254. Ainsi, les
plages d’adresses des réseaux privés de Lille, Lyon et Toulouse sont respectivement :
192.168.59.0/255.255.255.0, 192.168.69.0/255.255.255.0 et 192.168.31.0/255.255.255.0.
11
Les extrémités de chaque tunnel entre deux sites auront une adresse IP de la forme
10.1.<Numéro_Tunnel>.<Numéro_Dept_Extrémite>. Ainsi, la liste des adresses IP associées
aux tunnels sur chaque site est la suivante :
- Tunnel 1 : Lille - Lyon  10.1.1.59 - 10.1.1.69
- Tunnel 2 : Lille - Toulouse  10.1.2.59 - 10.1.2.31
- Tunnel 3 : Lyon – Toulouse  10.1.3.69 - 10.1.3.31
L’adresse IP de la passerelle est une adresse publique fixée localement par chaque site.
12
24) Globus
241) Présentation de Globus
Le but des outils comme Globus est de proposer une infrastructure en exploitation libre,
permettant de disposer des services de base nécessaires pour construire une application de
grille.
Le schéma ci-dessous nous illustre l’utilité de Globus qui correspond à implémentation d’une
couche intergiciel supplémentaire qui fait abstraction de l'hétérogénéité de l'environnement,
nous permettant de gérer dans une grille, le partage des ressources, la sécurité, l’équilibre de
la charge imposée aux ressources, la disponibilité des réseaux, et les normes.
13
Le programmeur n'a alors plus à se préoccuper de la différence entre les machines aussi bien
au niveau de l'authentification qu'au niveau de la recherche des ressources disponibles.
Pour atteindre ce but, les développeurs de Globus cherchent à établir et à faire respecter des
normes dans le développement des services s'intégrant à Globus. Ces normes se basent sur
des travaux de recherche au sein du "Global Grid Forum" qui ont pour but de recenser les
besoins des utilisateurs des technologies des grilles de calcul et sur la manière de les
implémenter. Ces recherches ont aboutit sur l'OGSA (Open Grid Services Architecture) et
l'OGSI (Open Grid Services Infrastructure), référence clé pour les projets d’élaboration de
grilles futurs. L’OGSI a été remplacé depuis début 2004 par WSRF (Web Services Resource
Framework), mécanisme permettant de définir, d’inspecter et de contrôler à distance l’état du
service. Il contribue à l’utilisation de la grille à très grande échelle, à sa fiabilité et à
l’interopérabilité entre la grille d’application et la grille de service.
242) Globus
a) Sécurité
La cryptographie à clés publiques est la base des certificats X.509 et SSL.
L'utilisation des certificats permet d'automatiser le processus d'authentification que ce soit un
utilisateur ou une machine. En effet, il suffit que les deux entités engagées dans la
communication s'assurent de l'identité de l'autre.
Exemple:
A veut établir une communication avec B, les deux veulent s'assurer qu'ils s'adressent à la
bonne personne.
A envoie son certificat signé à B qui le vérifie
B génère un message aléatoire et demande à A de le chiffrer
A chiffre le message à l'aide de sa clé privée et envoie le résultat à B.
B déchiffre le message à l'aide de la clé publique de A et vérifie que le message est identique
au message de départ. Si c'est le cas, A est bien celui qu'il prétend être.
A effectue les mêmes opérations pour être sûr de l'identité de B.
b) Découverte et la gestion des ressources et accès aux données
14
Certaines applications peuvent requérir une grande capacité de traitement. D’autres
applications requièrent des hautes performances de calcul. Ou encore pour accéder à un grand
volume de données, de les collecter, les mettre en mémoire, et les analyser.
Ainsi Globus permet d’améliorez la disponibilité globale d'un système réparti en surveillant
les composants critiques de système, en informant des interfaces gestionnaires quand les
services échouent, et la disponibilité d'enregistrement du moment fini de services pour
l'analyse postérieure.
243) Déploiement d’un service
Pour écrire et déployer un « Web Services Resource Framework » (WSRF), il faut cinq
grandes étapes :
1. Définir l’interface du service : Interface du service dans WSDL.
2. Implémenter le service : Fait en Java.
3. Définir les paramètres de déploiement : Descripteur de déploiement indiquant
comment présenter interface du service et l’implémentation du service au monde
externe (WSDD et JNDI)
4. Générer une archive GAR : Un seul fichier qui contient toutes les informations
nécessaire pour déployer le service avec l’utilitaire Ant.
5. Déployer le service : Déployer l’archive GAR sur la Grille avec Globus Toolkit.
244) Web Services
Les Web Services (WS) fournit une infrastructure souple pour les systèmes distribués, basée
sur XML. Ils sont vus comme des ensembles de fonctions invocables et peuvent être situés
n’importe où, appartenir à n’importe qui, être développés avec tous types d’outils et
s’exécuter sur n’importe quelle plateforme. De plus, ils assurent la confidentialité,
l’authentification et l’intégrité des messages.
Vous trouverez la structure d’un document « Web Services Description Language » (WSDL)
en annexe 1.1.
Le WSDD « Web Service Deployment Descriptor » permet le déploiement de services, et le
JNDI « Java Naming and Directory Interface » est utilisé pour stocker et obtenir un objet
Java. (Il est intégré au JDK à partir de sa version 1.3).
15
Ci-dessous, un exemple simple de Web Service :
245) Créer un fichier GAR avec ANT
Pour le moment nous avons une (1) interface de service dans WSDL, (2) une exécution de
service dans Java, et (3) un descripteur de déploiement dans WSDD et JNDI indiquant au
récipient de services de Web comment présenter (1) et (2) au monde externe. Cependant,
nous avons plusieurs fichiers. Comment pouvons nous placer ces fichiers dans un récipient de
services de Web ? Il faudrait donc copier ces fichiers à des endroits stratégique et bien
localisé.
Le plus simple pour déployer ces trois fichier serait de créer une archive de grille (GAR). Ce
fichier simple, contiendrait tous les fichiers et l'information du récipient de services de Web
qui doit déployer notre service et le rendre disponible au monde entier.
16
Ant est un outil de construction de Java, très similaire à la commande make sous Unix. Le
schéma qui suit vous montre l’utilité de Ant qui génére le fichier GAR directement à partir
des trois fichiers source.
3) Résultats:
31) Choix de l’environnement de travail
311) Choix du système d’exploitation (OS)
Le choix du système d'exploitation sur lequel nous avons installé Globus est RedHat 7.3 car il
n'y a aucun problème connu entre cet OS et Globus (cf : site de Globus). En effet cette
version de RedHat est l’une des plus stables et possède une large gamme de commandes et de
bibliothèques permettant de faire fonctionner Globus sans avoir à installer des patchs. Cela
17
aurait été le cas pour un système d’exploitation comme Debian dont le noyau ne peut pas
supporter certains fonctionnements de threads, ou encore Fedora Core qui a un problème avec
le logiciel requis « Ant ».
On a également remarqué que d’autres systèmes d’exploitation auraient pu être utilisés car,
comme RedHat, ne recensent pas de problèmes de fonctionnalité ni de bugs avec Globus.
312) Choix de la version de Globus
On a choisit Globus 4 car il y a plus d'interopérabilités, c'est-à-dire que les services sont
utilisables entre eux. Par ailleurs, Globus 4 propose une meilleure gestion des « Web
Services » (WSRF).
32) Installation de Globus
Avant d’installer Globus, il a fallu installer et configurer d'autres logiciels qui sont requis
pour son bon fonctionnement.
321) Logiciels pré requis
Le premier logiciel que nous avons installé est le compilateur JAVA. En effet, une grande
partie des applications concernant le Web Services nécessite des programmes écrits en Java.
Nous avons donc téléchargé et installé J2SE 1.4.2+ SDK qui contient JNDI.
Ensuite, il a fallu installer le logiciel ANT. Compilateur indispensable, Ant est un système de
gestion de build comparable à Make. Sa portabilité est garantie par l'usage du langage Java et
du format XML pour les fichiers de build. Il permet de générer un fichier GAR : Archive
facilitant le déploiement.
Deux autres logiciels ont également été indispensables à l’installation de Globus : le
compilateur GCC permettant de transformer les programmes C en exécutables, et le logiciel
POSTGRES qui permet la réalisation et l’utilisation de bases de données.
18
Nous avons aussi besoin des utilitaires Make et Tar.
Après l’installation de tous ces logiciels, il est conseiller de les tester à l’aide d’exemples
simples donnés en annexe 2.
322) Configuration de Globus
Tout d’abord, il faut compter plusieurs heures pour installer Globus. Le plus pratique est de
créer un utilisateur globus qui installera Globus. Une fois l’installation terminée, il faut des
certificats permettant l’identification de l’hôte et de l’utilisateur. Il faut donc un certificat hôte
pour globus et un certificat utilisateur.
323) Déploiement d’une application simple
Une fois Globus correctement installé et configuré, il faut procéder à une authentification
grâce à un certificat préalablement signé par l'utilisateur "Globus" qui fera office
d'administrateur (certificat hôte).
Normalement, pour pouvoir utiliser Globus, il faut créer soi-même un certificat que l’on
envoie ensuite à un administrateur (autorité Globus) qui le signe et le renvoie. Une fois le
certificat signé et reçu, Globus est opérationnel car les conditions de sécurité sont validées.
Cependant, dans un premier temps on choisit de signer le certificat (simpleCA) en local pour
la phase de tests. Lors de cette étape nous avons essayé de déployer le poste travail sur une
grille afin de tester le bon fonctionnement de Globus et des Web Services. Les certificats
peuvent être signé en local pour la phase de test. Mais, il faudrait par la suite demander les
certificats auprès des autorités Globus pour s’assurer d’une meilleure sécurité. Les différentes
étapes de la création d’un certificat sont données en annexe 3.
Pour tester Globus, on a pris des exemples simples comme celui exposée en annexe 4. Les
fichiers correspondant à cet exemple ce trouve en annexe 1.
Nous avons, dans un premier temps, définit un service web mathématique simple (coté
serveur) permettant de faire deux opérations (Addition et soustraction) et deux propriétés de
ressources (lire la valeur courante et lire la dernière opération effectuée).
19
Ensuite on génére l’archive GAR puis on la déploie sur la grille (globus-deploy-gar) et on
démarre le service (globus-start-container).
Puis coté client, on implémente (en Java) un programme simple permettant d’utiliser le
service web précédent.
Nous avons choisis de prendre un exemple qui ajoute 10 puis ajoute 5 à une variable
commune initialisée à 0. Puis nous affichons la valeur. Puis nous soustrayons 5 et nous
affichons de nouveau la valeur. Ceci peut être effectué par plusieurs utilisateurs. La variable
est gardée en mémoire. En testant avec un utilisateur, nous avons obtenue :
user1> valeur : 15, valeur : 10
Puis en testant cette même application avec deux utilisateurs presque en même temps, nous
avons obtenue :
user2> valeur : 25, valeur : 20
user3> valeur : 35, valeur : 30
Nous pouvons donc remarquer que cette donnée et identique pour tous les utilisateurs. De
plus, lorsqu’un utilisateur utilise la donnée, il bloque l’accès et la modification aux autres
utilisateurs (sémaphore). Nous pouvons donc affirmer que Globus gère bien la découverte et
la gestion des ressources ainsi qu l’accès aux données.
33) Mise en œuvre logicielle du VPN
La mise en œuvre logicielle du VPN sur chaque site s’appuie sur la technologie VTUN. Elle
comprend les étapes suivantes :
1. Installation de l’outil VTUN
2. Ouverture du port 7713 (7 comme 7ème lettre de l’alphabet i.e. G, et 13 comme
13ème lettre de l’alphabet i.e. M) sur la machine passerelle.
3. Autorisation des machines du réseau privé d’accéder au réseau public (Internet)
via la passerelle.
4. Création et activation des tunnels vers les deux autres sites.
331) Installation de VTUN
20
Il faut récupérer sur Internet les packages RPM pour VTUN pour la distribution Fedora
Core 2. La procédure d’installation et de démarrage du service vtund est la suivante :
rpm -q vtun
rpm -qa|grep -i vtun
rpm -qpl vtun-2.6-0.1.fc2.dag.i386.rpm
rpm -Uvh vtun-2.6-0.1.fc2.dag.i386.rpm
yum install vtun
rpm -Uvh vtun-2.6-0.1.fc2.dag.i386.rpm
yum install lzo
yum update
reboot
rpm -Uvh vtun-2.6-0.1.fc2.dag.i386.rpm lzo-1.08-2.1.fc2.dag.i686.rpm
chkconfig --list|grep tun
vi /etc/vtund.conf
chkconfig vtund on
service vtund start
332) Autorisation d’accès à Internet
Sur chaque site, pour autoriser l’accès à Internet aux machines du réseau privé à travers la
passerelle il faut utiliser le mécanisme d’ « IP masquerading » réalisé par la commande
suivante :
/sbin/iptables -t nat -A POSTROUTING -o eth0 -s 192.168.59.0/24 -d 0/0 -j MASQUERADE
333) Création et activation des tunnels
La création et activation des tunnels doivent être effectuées sur la passerelle de chaque
site. La création/configuration des tunnels doit être mise en place dans le fichier de
configuration /etc/vtund.conf. Pour chaque tunnel créé entre deux sites, chaque site joue le
rôle de serveur ou de client pour ce tunnel.
Si on considère un tunnel numéro i entre les sites xx et yy, la partie du fichier de
configuration /etc/vtund.conf qui lui est associée est la suivante :
# Tunnel i : xx-yy
(serveur côté xx)
xx-yy {
pass <taper le mot de passe>; # un moyen d'obtenir un mot
21
de passe : 'ps ax | md5sum'
type ether ;
# tunnel Ethernet
proto tcp; # Protocole de transport TCP
keepalive yes;
# Liste des programmes à lancer une fois la connexion établie
(initialisation des protocoles, du routage, etc.)
up {
ifconfig "%% 10.1.i.xx netmask 255.255.255.0";
route "add -net 192.168.yy.0 gw 10.1.i.yy netmask
255.255.255.0";
};
# Liste des programmes à lancer à la déconnexion
down {
ifconfig "%% down";
};
}
Exemples : Voici les parties du fichier de configuration correspondant aux tunnels 59-69 et
31-59.
59-69 {
pass ad415132e5664968f46ea62ebd3908bb ;
type ether;
proto tcp;
keepalive yes;
persist yes ;
up {
ifconfig "%% 10.1.32.59 netmask 255.255.255.0";
route "add -net 192.168.69.0 gw 10.1.32.69 netmask
255.255.255.0";
};
down { ifconfig "%% down";
};
}
31-59 {
22
pass d8f6607218f92bb25272e723022b502b;
type ether ;
proto tcp;
keepalive yes;
up {
ifconfig "%% 10.1.35.59 netmask 255.255.255.0";
route "add -net 192.168.31.0 gw 10.1.35.31 netmask
255.255.255.0";
};
down {
ifconfig "%% down";
};
}
Les commandes d’activation du tunnel sont :

Côté serveur (xx) : 'vtund -s'

Côté client (yy) : 'vtund xx-yy <Real-Ip-Passerelle-xx> -p'
L’option « -p » est utilisée pour le mode persistent uniquement par le client. Son
utilisation signifie que le client doit se re-connecter au serveur en fin de connexion.
Par exemple, l’activation du tunnel Lille (c)-Lyon (s) (59-69) en supposant que l’adresse
IP de la passerelle de Lyon est 69 140.77.166.28 est réalisée par les deux commandes
suivantes :
o Sur Lyon : vtund –s
o Sur Lille : /usr/sbin/vtund 59-69 140.77.166.28 –p
Conclusion:
A FAIRE
23
ANNEXES
1) Déploiement d’une application : Fichiers exemples
11) Définition de l’interface en Web Services Description Language-WSDL
Un service web est composé de plusieurs opérations. Chaque opération peut avoir une entrée
et/ou une sortie. Chacun de ces messages est composé de plusieurs parties. Chaque partie est
décrite par un type. Pour un protocole donné, les opérations associées constituent un port,
associé à une adresse.
Fichier dans: schema/examples/MathService_instance/Math.wsdl
111) Entête fichier WSDL:
<?xml version="1.0" encoding="UTF-8"?>
<definitions name="MathService"
targetNamespace="http://www.globus.org/namespaces/examples/core/MathService
_instance"
xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:tns="http://www.globus.org/namespaces/examples/core/MathService_insta
nce"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:wsrp="http://docs.oasis-open.org/wsrf/2004/06/wsrf-WSResourceProperties-1.2-draft-01.xsd"
xmlns:wsrpw="http://docs.oasis-open.org/wsrf/2004/06/wsrf-WSResourceProperties-1.2-draft-01.wsdl"
xmlns:wsdlpp="http://www.globus.org/namespaces/2004/10/WSDLPreprocessor"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<wsdl:import
namespace=
"http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceProperties1.2-draft-01.wsdl"
location="../../wsrf/properties/WS-ResourceProperties.wsdl" />
112) Types (Définition XML Schéma des données) :
<types>
<xsd:schema
targetNamespace="http://www.globus.org/namespaces/examples/core/MathService
_instance"xmlns:tns="http://www.globus.org/namespaces/examples/core/MathSer
vice_instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
24
<!-- REQUESTS AND RESPONSES -->
<xsd:element name="add" type="xsd:int"/>
<xsd:element name="addResponse">
<xsd:complexType/>
</xsd:element>
<xsd:element name="subtract" type="xsd:int"/>
<xsd:element name="subtractResponse">
<xsd:complexType/>
</xsd:element>
<xsd:element name="getValueRP">
<xsd:complexType/>
</xsd:element>
<xsd:element name="getValueRPResponse" type="xsd:int"/>
<!-- RESOURCE PROPERTIES -->
<xsd:element name="Value" type="xsd:int"/>
<xsd:element name="LastOp" type="xsd:string"/>
<xsd:element name="MathResourceProperties">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="tns:Value" minOccurs="1"
maxOccurs="1"/>
<xsd:element ref="tns:LastOp" minOccurs="1"
maxOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
</types>
113) Messages (Collections de types) :
<message name="AddInputMessage">
<part name="parameters" element="tns:add"/>
</message>
<message name="AddOutputMessage">
<part name="parameters" element="tns:addResponse"/>
</message>
<message name="SubtractInputMessage">
<part name="parameters" element="tns:subtract"/>
</message>
<message name="SubtractOutputMessage">
<part name="parameters" element="tns:subtractResponse"/>
</message>
<message name="GetValueRPInputMessage">
<part name="parameters" element="tns:getValueRP"/>
</message>
<message name="GetValueRPOutputMessage">
<part name="parameters" element="tns:getValueRPResponse"/>
</message>
114) Ports types (Ensembles d’opérations) :
<portType name="MathPortType"
wsdlpp:extends="wsrpw:GetResourceProperty"
wsrp:ResourceProperties="tns:MathResourceProperties">
<operation name="add">
<input message="tns:AddInputMessage"/>
<output message="tns:AddOutputMessage"/>
25
</operation>
<operation name="subtract">
<input message="tns:SubtractInputMessage"/>
<output message="tns:SubtractOutputMessage"/>
</operation>
<operation name="getValueRP">
<input message="tns:GetValueRPInputMessage"/>
<output message="tns:GetValueRPOutputMessage"/>
</operation>
</portType>
115) Fin de balise définition :
</definitions>
12) Impémentation du service en java :
121) MathQNames
Fichier dans : org/globus/examples/services/core/first/impl/MathQNames.java
package org.globus.examples.services.core.first.impl;
import javax.xml.namespace.QName;
public interface MathQNames {
public static final String NS =
"http://www.globus.org/namespaces/examples/core/MathService_instance";
public static final QName RP_VALUE = new QName(NS, "Value");
public static final QName RP_LASTOP = new QName(NS, "LastOp");
public static final QName RESOURCE_PROPERTIES = new QName(NS,
"MathResourceProperties");
}
122) MathService
Fichier dans : org/globus/examples/services/core/first/impl/MathService.java
package org.globus.examples.services.core.first.impl;
import java.rmi.RemoteException;
import org.globus.wsrf.Resource;
import org.globus.wsrf.ResourceProperties;
import org.globus.wsrf.ResourceProperty;
import org.globus.wsrf.ResourcePropertySet;
import org.globus.wsrf.impl.ReflectionResourceProperty;
import org.globus.wsrf.impl.SimpleResourcePropertySet;
import org.globus.examples.stubs.MathService_instance.AddResponse;
import org.globus.examples.stubs.MathService_instance.SubtractResponse;
import org.globus.examples.stubs.MathService_instance.GetValueRP;
26
public class MathService implements Resource, ResourceProperties {
/* Resource Property set */
private ResourcePropertySet propSet;
/* Resource properties */
private int value;
private String lastOp;
/* Constructor. Initializes RPs */
public MathService() throws RemoteException {
/* Create RP set */
this.propSet = new SimpleResourcePropertySet(
MathQNames.RESOURCE_PROPERTIES);
/* Initialize the RP's */
try {
ResourceProperty valueRP = new ReflectionResourceProperty(
MathQNames.RP_VALUE, "Value", this);
this.propSet.add(valueRP);
setValue(0);
ResourceProperty lastOpRP = new ReflectionResourceProperty(
MathQNames.RP_LASTOP, "LastOp", this);
this.propSet.add(lastOpRP);
setLastOp("NONE");
} catch (Exception e) {
throw new RuntimeException(e.getMessage());
}
}
/* Get/Setters for the RPs */
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public String getLastOp() {
return lastOp;
}
public void setLastOp(String lastOp) {
this.lastOp = lastOp;
}
/* Remotely-accessible operations */
public AddResponse add(int a) throws RemoteException {
value += a;
lastOp = "ADDITION";
return new AddResponse();
27
}
public SubtractResponse subtract(int a) throws RemoteException {
value -= a;
lastOp = "SUBTRACTION";
return new SubtractResponse();
}
public int getValueRP(GetValueRP params) throws RemoteException {
return value;
}
/* Required by interface ResourceProperties */
public ResourcePropertySet getResourcePropertySet() {
return this.propSet;
}
}
123) Client
Fichier dans : org/globus/examples/clients/MathService_instance/Client.java
package org.globus.examples.clients.MathService_instance;
import org.apache.axis.message.addressing.Address;
import org.apache.axis.message.addressing.EndpointReferenceType;
import org.globus.examples.stubs.MathService_instance.MathPortType;
import org.globus.examples.stubs.MathService_instance.GetValueRP;
import
org.globus.examples.stubs.MathService_instance.service.MathServiceAddressin
gLocator;
public class Client {
public static void main(String[] args) {
MathServiceAddressingLocator locator = new
MathServiceAddressingLocator();
try {
String serviceURI = args[0];
// Create endpoint reference to service
EndpointReferenceType endpoint = new
EndpointReferenceType();
endpoint.setAddress(new Address(serviceURI));
MathPortType math =locator.getMathPortTypePort(endpoint);
// Get PortType
math = locator.getMathPortTypePort(endpoint);
// Perform an addition
math.add(10);
// Perform another addition
math.add(5);
// Access value
System.out.println("Current value: "
+ math.getValueRP(new GetValueRP()));
// Perform a subtraction
math.subtract(5);
// Access value
System.out.println("Current value: "
+ math.getValueRP(new GetValueRP()));
} catch (Exception e) {
e.printStackTrace();
}
}
}
28
13) descripteur de déploiement WSDD :
Fichier dans : org/globus/examples/services/core/first/deploy-server.wsdd
<?xml version="1.0" encoding="UTF-8"?>
<deployment name="defaultServerConfig"
xmlns="http://xml.apache.org/axis/wsdd/"
xmlns:java="http://xml.apache.org/axis/wsdd/providers/java"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<service name="examples/core/first/MathService" provider="Handler"
use="literal" style="document">
<parameter name="className"
value="org.globus.examples.services.core.first.impl.MathService"/>
<wsdlFile>share/schema/examples/MathService_instance/Math_service.wsdl</wsd
lFile>
<parameter name="allowedMethods" value="*"/>
<parameter name="handlerClass"
value="org.globus.axis.providers.RPCProvider"/>
<parameter name="scope" value="Application"/>
<parameter name="providers" value="GetRPProvider"/>
<parameter name="loadOnStartup" value="true"/>
</service>
</deployment>
14) Fichier de déploiement JNDI :
Fichier dans : org/globus/examples/services/core/first/deploy-jndi-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<jndiConfig xmlns="http://wsrf.globus.org/jndi/config">
<service name="examples/core/first/MathService">
<resource name="home"
type="org.globus.wsrf.impl.ServiceResourceHome">
<resourceParams>
<parameter>
<name>factory</name>
<value>org.globus.wsrf.jndi.BeanFactory</value>
</parameter>
</resourceParams>
</resource>
</service>
</jndiConfig>
29
2) Logiciels requis
21) Exemple simple pour tester le bon fonctionnement
211) JAVA JDK 1.4.2+ :
a) Créer le fichier "BonjourMonde.java" suivant :
/*****************************************************
*** Ce programme se contente d'afficher le méssage ***
*** "Bonjour tout le monde !"
***
*****************************************************/
public class BonjourMonde {
// Définition de la méthode statique main
public static void main(String params[]){
System.out.println("Bonjour tout le monde !");
}
}
b) Compilation :
>javac BonjourMode.java
c) Exécution :
>java BonjourMonde
Bonjour tout le monde !
>
212) ANT :
Ant permet d’offrir un outil semblable à make mais portable et extensible grâce à Java.
L’implémentation de tout projet Ant est définit via un fichier XML.
a) Créer le fichier "build.xml" suivant :
<?xml version="1.0" encoding="ISO-8859-1"?>
30
<project name="Test avec Ant" default="init" basedir=".">
<!-==================================================================
= -->
<!-- Initialisation -->
<!-==================================================================
= -->
<target name="init">
<echo message="Debut des traitements" />
<echo>
Fin des traitements du projet ${ant.project.name}
</echo>
<echo file="${basedir}/log.txt" append="false" message="Debut des traitements" />
<echo file="${basedir}/log.txt" append="true" >
Fin des traitements
</echo>
</target>
</project>
b) Exécution :
Ce placer dans le répertoire où a été créé le fichier build.xml et faire :
>ant
213) GCC :
a) Créer le fichier "hello.c" suivant :
// Exemple de programme C qui va afficher
// sur l'écran, le message "Hello world !!"
#include <stdio.h>
void main(void)
{
printf("Hello world !!\n");
}
b) Compilation:
> gcc -o hello hello.c
c) Execution:
> ./hello
Hello world !!
>
31
214) TAR :
a) Compression :
> tar czvf <nom_fichier ou dossier> <nom_fichier>.tar.gz
b) Décompression :
> tar xzvf <nom_fichier>.tar.gz
215) MAKE :
a) Créer les fichiers suivants :
Fichier "math.h" :
int add(int x, int y);
Fichier "math.c" :
int add(int x,int y){
if (y==0) {
return x;
} else {
return add(++x,--y);
}
}
Fichier "main.c" :
#include <stdio.h>
#include "math.h"
int main(void){
printf("%d\n",add(3,5));
}
Fichier "makefile" :
CC=gcc
OBJET=math.o main.o
BIN= ajouteur
all: $(OBJET)
$(CC) -o $(BIN) $(OBJET)
math.o: math.c
main.o: main.c math.h
32
b) Compilation:
> make
c) Execution:
> ./ajouteur
22) Configuration du path pour tous les utilisateurs :
Editer le fichier /etc/profile :
// configuration du classpath :
// repertoire courant de java
classpath=$classpath:/usr/java/j2re1.4.2_02/
// repertoire courant de junit
classpath=$classpath:/usr/local/junit3.8.1/junit.jar
// repertoire courant de postgreSQL
classpath=$classpath:/usr/local/pgsql/
// variable d'environement
// Java
export JAVA_HOME=/usr/java/j2re1.4.2_02/
// Ant
export ANT_HOME=/usr/local/junit3.8.1/junit.jar
// postgreSQL
export PGSQL_HOME=/usr/local/pgsql/bin/
// variable d'environement Globus et execution du script globus-user-env.sh
export GLOBUS_LOCATION=/usr/local/globus-3.9.5
export GPT_LOCATION=/usr/local/globus-3.9.5
. $GLOBUS_LOCATION/etc/globus-user-env.sh
// variable path
PATH=$PATH:${PGSQL_HOME}/bin:${JAVA_HOME}/bin:${ANT_HOME}/bin
export PATH classpath USER LOGNAME MAIL HOSTNAME HISTSIZE INPUTRC
33
3) Globus toolkit :
31) Installation
Creer un utilisateur globus.
en root :
root> mkdir /usr/local/globus-3.9.5
root> chown globus:globus /usr/local/globus-3.9.5
en globus :
globus> export GLOBUS_LOCATION=/usr/local/globus-3.9.5
globus> ./configure --prefix=$GLOBUS_LOCATION
globus> export GLOBUS_LOCATION=/usr/local/globus-3.9.5
globus> ./configure --prefix=$GLOBUS_LOCATION
// l'installation peut prendre plusieurs heures
globus> make 2>&1 | tee build.log
// variable d'environement
globus> export GLOBUS_LOCATION=/usr/local/globus-3.9.5
globus> . $GLOBUS_LOCATION/etc/globus-user-env.sh
32) Création d’un certificat en local
Dans /etc/hosts mettre 127.0.0.1 localhost.localdomain localhost nom_machine.
Créer un utilisateur.
321) Créer certificat host
globus>cd ~globus
globus>grid-cert-request -host 'nom_machine'
globus>cd /etc/grid-security/
globus>grid-ca-sign -in hostcert_request.pem -out hostcert.pem
root> cd /etc/grid-security
root> cp hostkey.pem containerkey.pem
root> cp hostcert.pem containercert.pem
root> chown globus.globus containerkey.pem containercert.pem
322) Créer certificat user
user> cd ~user
user> grid-cert-request
globus> cd ~user/.globus
globus> grid-ca-sign -in usercert_request.pem -out usercert.pem
34
323) ajout mapfile
user> grid-cert-info -subject
/O=Grid/OU=GlobusTest/OU=simpleCA-globus/CN=user
user> whoami
user
globus> grid-mapfile-add-entry –dn \
"/O=Grid/OU=GlobusTest/OU=simpleCA-globus/CN=user" -ln user
On vérifie l'entrée avec : cat /etc/grid-security/grid-mapfile
324) Vérification du certificat
user> grid-proxy-init -debug -verify
User Cert File: /home/user/.globus/usercert.pem
User Key File: /home/user/.globus/userkey.pem
Trusted CA Cert Dir: /etc/grid-security/certificates
Output File: /tmp/x509up_u503
Your identity: /O=Grid/OU=GlobusTest/OU=simpleCA-globus/CN=user
Enter GRID pass phrase for this identity:
Creating proxy .....++++++++++++
..............++++++++++++
Done
Proxy Verify OK
Your proxy is valid until: Wed May 25 03:55:13 2005
4) Test Globus
Exemple déploiement application globus
41) Télécharger l’exemple à l’adresse suivante :
http://gdp.globus.org/gt4-tutorial/download/progtutorial-examples_0.1.tar.gz
42) Décompresser l'exemple :
user> mkdir examples
user> cd examples
user> tar xzvf /examples/progtutorial-examples_0.1.tar.gz
user> chmod 700 globus-build-service.sh
user> ./globus-build-service.sh first
user> source $GLOBUS_LOCATION/etc/globus-devel-env.sh
35
43) Lancer Web Services:
globus> globus-deploy-gar ./org_globus_examples_services_core_first.gar
globus> globus-start-container -nosec
44) Compilation :
user> javac -classpath ./build/stubs/classes/:$CLASSPATH \
org/globus/examples/clients/MathService_instance/Client.java
45) Execution:
user> java -classpath ./build/stubs/classes/:$CLASSPATH \
org.globus.examples.clients.MathService_instance.Client \
http://127.0.0.1:8080/wsrf/services/examples/core/first/MathService
46) Résultat:
user1> java -classpath ./build/stubs/classes/:$CLASSPATH \
org.globus.examples.clients.MathService_instance.Client \
Current value: 15
Current value: 10
user2> java -classpath ./build/stubs/classes/:$CLASSPATH \
org.globus.examples.clients.MathService_instance.Client \
http://127.0.0.1:8080/wsrf/services/examples/core/first/MathService
user3> java -classpath ./build/stubs/classes/:$CLASSPATH \
org.globus.examples.clients.MathService_instance.Client \
http://127.0.0.1:8080/wsrf/services/examples/core/first/MathService
Current value: 25
Current value: 20
Current value: 35
Current value: 30
36
Téléchargement
Explore flashcards