mise en place d'une application de gestion des tâches récurrentes
TRANSCRIPT
Rapport de stage (du 24/03 au 4/07)
Extension de la Console de gestion Microsoft.
Mise en place d’une application de gestion des tâches récurrentes.
2014
Conseil Général du Doubs
Responsable : Alexandre Caro
Professeur tuteur : Bénédicte Herrmann
Charlélie PETRACCA
Licence Pro SIL CDOOAM
2
Remerciements
Je souhaite tout d’abord remercier Gérôme Aubert pour m’avoir accepté au sein de
son équipe et pour avoir su me proposer des travaux et projets enrichissants tout au long de
mon stage.
Je voudrais remercier Alexandre Caro, pour avoir été mon responsable lors de ce
stage et pour m’avoir suivi et conseillé dans mon travail.
Je remercie également toutes les personnes qui ont pris du temps pour m’aider dans
la réalisation de mes projets et pour m’expliquer le fonctionnement du système
d’informations du Conseil général.
- Sébastien Boetsch qui m’a beaucoup aidé dans la compréhension du
système,
- Fréderic Gaillard pour m’avoir présenté le matériel système et réseau.
- Nicolas Druoton pour son aide en web et en algorithmique,
Pour finir, je souhaite remercier l’ensemble de l’équipe de l’exploitation informatique
qui a été disponible qui m’a accueilli dans de très bonnes conditions.
3
Table des matières
Remerciements……………………………………………………………………………………………………………………..2
Table des matières………………………………………………………………………………………………………………..3
Introduction………………………………………………………………………………………………………………………….5
I. Présentation du contexte……………………………………………………………………………………………………6
A. Le Conseil Général du Doubs……….…………………………………………………………………………7
B. Le service des systèmes informatiques…………………………………………………………………..8
1. Organigramme……………………………………………………………………………………………8
2. Fonctionnement…………………………………………………………………………………………9
C. Organisation informatique…………………………………………………………………………………..10
1. Le parc informatique…………………………………………………………………………………10
2. Virtualisation…………………………………………………………………………………………….10
II. Projet d’extension de la MMC…………………………………………………………………………………………11
A. Présentation du sujet………………………………………………………………………………………..…12
1. Explication de l’intitulé du sujet………………………………………………………………..12
2. Objectifs du projet……………………………………………………………………………………13
B. Travail Réalisé………………………………………………………………………………………………………14
1. Prise en main des outils…………………………………………………………………………….14
2. Documentation sur l’extension de la MMC……………………………………………….17
3. Solution apportée – script C++………………………………………………………………….18
C. Bilan…………………………………………………………………………………………………………………….21
1. Compétences acquises……………………………………………………………………………..21
2. Évolutions possibles………………………………………………………………………………….21
4
III. Projet de gestion des tâches récurrentes………………………………………………………………………..22
A. Présentation du sujet…………………………………………………………………………………………..23
1. Contexte……………………………………………………………………………………………….....23
2. Objectif…………………………………………………………………………………………………….24
3. Cahier des charges……………………………………………………………………………………24
B. Travail Réalisé………………………………………………………………………………………………………25
1. Conception……………………………………………………………………………………………….25
2. Fonctionnalités…………………………………………………………………………………………27
3. Ergonomie………………………………………………………………………………………………..30
4. Difficultés rencontrées……………………………………………………………………………..30
C. Bilan…………………………………………………………………………………………………………………….32
1. Compétences acquises……………………………………………………………………………..32
2. Évolutions possibles………………………………………………………………………………….32
IV. Travaux sur le monitoring………………………………………………………………………………………………33
A. Le monitoring………………………………………………………………………………………………………34
B. Objectifs du projet……………………………………………………………………………………………….34
C. Travaux réalisés……………………………………………………………………………………………………34
D. Évolutions possibles…………………………………………………………………………………………….35
Conclusion…………………………………………………………………………………………………………………………..36
Annexes………………………………………………………………………………………………………………………………37
1. Microsoft Active Directory……………………………………………………………………………………38
2. Le protocole LDAP………………………………………………………………………………………………..39
3. Script C++ du projet d’extension de la MMC………………………………………………………..43
Lexique………………………………………………………………………………………………………………………………..47
Bibliographie……………………………………………………………………………………………………………………….49
5
Introduction
Actuellement en Licence professionnelle « Systèmes informatiques et logiciels »
option « Conception et développement orientés objets d’applications multi-tiers » à
l’Université de Besançon, j’ai dû effectuer un stage de 15 semaines au sein de l’équipe
informatique d’une entreprise ou d’une organisation. Un projet doit être réalisé durant cette
période et un rapport doit être présenté, appuyé par une soutenance de stage. Ce module
est le plus important de la Licence, tant au niveau du coefficient qu’au niveau pédagogique.
Ce stage doit en effet permettre de faire le lien entre la formation suivie tout au long de
l’année et le milieu professionnel.
C’est au sein du Conseil Général du Doubs que j’ai effectué mon stage. Le Conseil
Général est l’assemblée délibérante du département, élue au suffrage universel. Ses
missions sont nombreuses, il contribue par exemple au développement économique par
l’attribution d’aides à la création d’entreprises. Il effectue une action d’aide à l’enfance, aux
handicapés et aux personnes âgées avec la mise en place de centres médicaux sociaux,
d’aide à l’enfance ou autres. Le Conseil Général intervient dans des domaines comme
l’éducation de la jeunesse et des sports, la protection de l’environnement ou encore le
développement des voies de communications et des transports.
J’ai été admis dans le service des systèmes d’informations, au sein du pôle
exploitation informatique composée de l’équipe d’administrateurs système ainsi que de
l’équipe de télécommunication. Ma mission initiale était de travailler sur l’annuaire
informatique du Conseil Général, mais ayant réalisé d’autres tâches aussi importantes, j’ai
décidé de vous les présenter dans ce rapport. Ainsi, nous aborderons trois parties
concernant trois projets différents que j’ai réalisés pendant mon stage. Dans un premier
temps, je vous présenterai le contexte de ce stage. Les parties 2 et 3 concerneront mes deux
projets principaux, l’extension du schéma Active Directory pour lier le service informatique
au service des ressources humaines, et le développement d’une application web pour
assister la vérification par les agents de toutes les tâches automatisées qui ont lieu la nuit.
Enfin, dans une dernière partie, je vous parlerai du projet de monitoring auquel j’ai
contribué.
6
I. Présentation du contexte
A. Le CG 25
B. Le service des systèmes informatiques
C. Organisation informatique
7
I. Présentation du contexte
En France, le conseil général est l'assemblée délibérante élue au suffrage universel
d'un département.
A. Le Conseil Général du Doubs
Il est composé de l’assemblée départementale, de la commission permanente
ainsi que de diverses commissions spécialisées.
- Le président
Claude JEANNEROT, réélu en mars 2011
� Pouvoir exécutif du Département
� Convoque et préside l’assemblée
� Propose les délibérations soumises à l’approbation des élus
� Met en œuvre et exécute les décisions de l’assemblée
- L’assemblée départementale
35 Conseillers généraux (1 par canton)
� Pouvoir délibératif
� Gère les affaires du Département (délibérations)
� Vote le budget du département
- La commission permanente
35 élus (le président, 10 vice-présidents, 3 conseillers généraux délégués et 21 conseillers
généraux)
� Compétences déléguées par le Conseil général
� Ne peux pas voter le budget
8
- Les commissions spécialisées
� Etudient les dossiers qui seront ensuite débattus lors des assemblées plénières.
� Rôle exclusivement consultatif
� Instaurées par le Conseil général selon ses besoins
B. Le service des systèmes informatiques
Le SSI du CG du Doubs est dirigé par M. Gunther BAEKELANDT.
1. Organigramme
Organigramme du service des systèmes informatique du Conseil Général du Doubs
9
2. Fonctionnement
o Pôle Assistance
Dirigé par Thierry Durand, ce pôle a pour missions l’assistance technique auprès des
utilisateurs de l’organisme ainsi que la maintenance et l’évolution du parc informatique. Il
est divisé en 2 secteurs : l’un est chargé de l’assistance départementale (SVP Département)
et l’autre s’occupe de l’assistance des communes du Doubs (SVP Commune).
o Pôle Solution et Métier
Ce pôle a pour missions l’intégration et le développement d’applications et de bases
de données répondants aux besoins des usagers. On y trouve le service Système
d’Information géographique qui a pour fonction de cartographier le département (numériser
la géographie du Doubs).
o Pôle Infrastructure
Supervisé par Gérôme Aubert, ce pôle a pour mission la mise en place et la
coordination d’une politique de sécurité. Il a également pour but d’assurer le bon
fonctionnement du système d’information (système de stockage, cœur de réseau, ferme de
serveurs VMware, serveur AIX, ToIP sous Lync). Ce pôle est en évolution constante pour
garder l’infrastructure réseau à jour.
Il est divisé en 3 groupes :
- Chef de projet technique, M. Marc Antoine CHATELAIN. Il a pour mission
de coordonner les projets en cours.
- Intégrateur, M. Jean-Claude Carré. Il a pour mission d’assurer la pleine
compatibilité des logiciels métiers implantés ou à implanter au sein du
système d’information.
- Exploitation informatique, composée de 5 techniciens en charge de la
bonne gestion de l’infrastructure serveur et réseau. Cette équipe est
constituée de 3 administrateurs et 2 techniciens Telecom.
10
C. Organisation informatique
1. Le parc informatique
L’ensemble du parc clients et serveurs s’appuie sur des technologies Microsoft
Windows, Windows XP et Windows Seven pour les postes clients et Windows serveur
entreprise 2003 R2 et 2008 R2 pour les serveurs. Seuls les 2 serveurs de gestion de base de
données (oracle) s’appuient sur une base AIX.
Le parc informatique et téléphonique géré par le Conseil général est composé
d’environ 2000 postes de travail, 350 systèmes d’impression, 110 commutateurs et 75
serveurs répartis sur 89 sites distants à travers le territoire départemental et 70 répartis au
sein des systèmes d’information.
Le secteur de la téléphonie représente une part importante du parc matériel
composant le système d’information. En effet, l’ensemble de la collectivité comprend
environ 1900 postes de téléphonie fixe et environ 530 mobiles.
2. Virtualisation
La virtualisation consiste à faire fonctionner plusieurs systèmes d’exploitation ou
applications sur un serveur comme de simples logiciels que l’on appelle environnements
virtuels. La virtualisation de systèmes d’exploitation permet de n’utiliser qu’un seul
ordinateur pour faire tourner plusieurs systèmes comme s’ils fonctionnaient sur des
ordinateurs distincts. Les avantages de cette technique sont nombreux :
- Utilisation optimale des ressources (la charge en ressources des
environnements virtuels est répartie sur les machines physiques)
- Installation et déploiement facile des machines virtuelles
- Economies sur le matériel (consommation, entretien, surveillance…)
- Allocation dynamique de la puissance de calcul en fonction des besoins de
chaque application
Actuellement, il y a au Conseil général du Doubs 13 serveurs physiques pour plus
d’une centaine d’environnements virtuels.
11
II. Projet d’extension de la MMC
A. Présentation du sujet
B. Travail Réalisé
C. Bilan
12
II. Projet d’extension de la MMC
La console de gestion Microsoft (MMC) permet notamment d’accéder à la gestion
des utilisateurs du domaine (en l’occurrence un annuaire Active Directory). Cette interface
est extensible et on peut théoriquement ajouter ou modifier des menus ou même des
feuilles de propriétés.
A. Présentation du sujet
Ce projet doit permettre d’enregistrer le numéro de matricule des employés
dans les attributs de leur compte utilisateur. Cela créera le lien entre chaque employé du CG
et son compte utilisateur dans le domaine.
1. Explication de l’intitulé du sujet
1.1. Extension du schéma Active Directory (AD)
Dans Active Directory, les domaines sont regroupés de manière arborescente pour
partager des ressources. L’ensemble des arbres forment ce qu’on appelle la forêt AD.
Le schéma Active directory définit chaque classe d’objet pouvant être créée dans une
forêt AD. Il contient également les définitions de chaque attribut existant dans un objet AD.
Le schéma d’origine contient de nombreuses classes et attributs mais il est possible
de l’étendre en ajoutant, par exemple, des attributs à un objet.
Cependant, étendre le schéma est une opération déconseillée puisqu’une erreur lors
de la modification peut entraîner la perte et l’altération de données.
Le schéma d’origine possède de nombreux attributs dont beaucoup ne sont pas
utilisés, il est donc souvent possible de les utiliser au lieu dans créer de nouveaux.
1.2. Extension de la Microsoft Management Console (MMC)
La MMC est une console de management qui permet de regrouper la gestion de
plusieurs modules appelés Snap-Ins (fichiers logiciels enfichables), notamment ADUC
(Utilisateurs et ordinateurs Active Directory). ADUC permet, entre-autres, la gestion de tous
les ordinateurs, utilisateurs ou encore groupes d’utilisateurs du domaine Active Directory.
13
2. Objectifs du projet
2.1. Liaison entre RH et Informatique
Dans une organisation comme le Conseil Général, il y a bien souvent plusieurs
annuaires qui sont utilisés. Le réseau informatique utilise l’annuaire Active Directory pour la
gestion des ordinateurs et des utilisateurs comme vu précédemment, mais d’autres services
peuvent très bien utiliser un autre annuaire pour leur propre fonctionnement. Au CG25,
c’est par exemple le cas pour le service des ressources humaines qui utilise un annuaire
propre à leur logiciel de gestion. Dans certaines organisations, on peut parfois décompter 4
ou 5 annuaires.
Un tel phénomène pose un problème de duplication des données puisqu’ils
contiennent souvent des informations très similaires, ainsi que la perte de données car les
données présentes dans un annuaire n’apparaissent pas forcément dans un autre.
Dans ce projet, l’extension du schéma est mise en place afin de permettre d’ajouter à
l’annuaire informatique (LDAP), des informations communes avec le service RH, comme le
numéro de matricule de l’employé (et utilisateur).
Une telle liaison ouvrirait des possibilités concernant l’automatisation d’un certain
nombre de tâches (comme l’envoi des fiches de paye par exemple).
2.2. Utilisation de nouveaux attributs
Lorsque l’on accède aux propriétés d’un objet AD, une page de propriétés s’affiche,
contenant une partie des attributs de l’objet, ceux qui sont les plus souvent utilisés.
Si l’on veut utiliser de nouveaux attributs pour un objet (qu’il s’agisse d’une
modification du schéma AD ou non), ils ne seront pas visible depuis la feuille de propriétés,
or il est impératif de pouvoir accéder à ces attributs, ainsi que de pouvoir les modifier.
Mon objectif dans ce projet est la mise en place de l’accès aux nouveaux attributs.
14
B. Travail Réalisé
Pour atteindre mon objectif dans ce projet, j’ai dû utiliser des outils que je ne
connaissais pas et j’ai dû commencer par une étape de documentation importante,
notamment à propos des technologies d’annuaires Microsoft.
1. Prise en main des outils
1.1. Annuaires
Dans le monde de l’informatique, un annuaire est un système de stockage de
données, permettant en particulier de conserver les données n’étant que peu mises à jour,
comme les coordonnées des personnes, clients ou encore fournisseurs d’une entreprise.
Les annuaires vérifient les caractéristiques suivantes :
- Ils sont conçus pour être plus souvent consultés que mis à jour,
- Les données sont stockées de manière hiérarchique et non pas de manière
tabulaire comme dans les bases de données relationnelles,
- Ils comportent des mécanismes de recherche facile et d’organisation des
résultats,
- Ils doivent pouvoir être répartis et doivent donc comporter des mécanismes
permettant de coopérer,
- Ils doivent être capables de gérer l’authentification des utilisateurs ainsi que les
droits d’accès aux données.
On peut utiliser un annuaire pour :
- Constituer un carnet d’adresse,
- Authentifier des utilisateurs (grâce à un mot de passe),
- Définir les droits de chaque utilisateur,
- Recenser des informations sur un parc matériel (ordinateurs, serveurs, Adresses
IP, adresses MAC, etc…),
- Décrire les applications disponibles.
15
1.2. Microsoft Active Directory
AD DS (Active Directory Domain Services) est un service d’annuaire de Microsoft basé
sur les standards TCP/IP : DNS, LDAP, Kerberos, etc… Il référencie les personnes (nom,
prénom, téléphone, etc…) ainsi que toute sorte d’objet, dont les groupes d’utilisateur, les
ordinateurs, les serveurs, les imprimantes, etc… Les contrôleurs de domaine AD DS
permettent également d’authentifier les comptes utilisateurs et les ordinateurs lorsqu’ils se
connectent au domaine.
Active Directory est un outil destiné aux utilisateurs mais il constitue également un
outil d’administration et de gestion du réseau. Il permet de gérer le réseau entier car on
dispose d’une vue sur l’ensemble des ressources et des droits associés.
Des informations plus détaillées sur AD sont fournies en annexe 1.
1.3. Protocole LDAP
Les annuaires peuvent être implémenté différemment d’un serveur à un autre, c’est
là qu’intervient LDAP (Lightweight Directory Access Protocol). LDAP est un protocole
d’annuaire standard et extensible. C’est une interface normalisée qui permet d’accéder de
façon standard aux différents services de l’annuaire. Plus simplement, son rôle est de
fournir un moyen unique d’effectuer des requêtes sur un annuaire compatible LDAP.
Des informations plus détaillées sur le protocole LDAP sont fournies en annexe 2.
16
1.4. C++ Builder 2007
Code Gear C++ Builder est un environnement de développement C++. Il permet
notamment la création d’interfaces graphiques à la souris.
Module de C++Builder 2007 pour la création d’une interface graphique.
Le code de cette interface est généré automatiquement et il est possible
d’implémenter des méthodes de gestion des événements comme le clic sur un bouton.
17
2. Documentation sur l’extension de la MMC
2.1. Microsoft Technet
Le Technet de Microsoft est une documentation complète des produits Microsoft en
ligne. Il contient notamment la documentation des classes C++, C# et Visual Basic
développées par Microsoft.
Des cours et tutoriels sont également disponibles, on y trouve même quelques
exemples de code.
2.2. Projet ADUaCET
ADUaCET (Active Directory Users and Computers Extension Tool) est un projet C#
disponible sur internet, il concerne l’extension des pages de propriétés d’un utilisateur AD
dans la MMC.
L’objectif de ce projet est d’ajouter une feuille de propriétés contenant un champ qui
permet la modification de l’attribut « employeeId » pour un utilisateur AD, ainsi qu’une
image.
Lorsque l’on clique sur le menu « propriétés » d’un utilisateur, la MMC charge une
liste de fichier contenant les feuilles de propriétés à afficher. Le principe du projet ADUaCET
est de créer un de ces fichiers et d’indiquer à la MMC de le charger lorsque l’on souhaite
afficher les propriétés d’un utilisateur.
2.3. Problèmes rencontrés
Le développement d’une page de propriétés et sont importation dans la MMC sont
des opérations lourdes et complexes. Pour le déploiement sur l’ensemble du domaine, il est
très préférable de choisir la solution la plus simple possible.
18
3. Solution apportée - Script depuis le menu contextuel
3.1. Modification de la configuration AD
Comme la modification du schéma ou des feuilles de propriétés, Active Directory
permet d’étendre les menus contextuels. Il s’agit en fait d’indiquer dans la configuration AD
que l’on souhaite ajouter un menu sur tel ou tel type d’objet (comme un utilisateur) et que
tel script doit être exécuté lors du clic sur ce menu.
L’avantage de cette solution est qu’il n’y a pas besoin de modifier les pages de
propriétés mais simplement de créer une fenêtre contenant les champs nécessaires, et de
les remplir en récupérant les données dans l’annuaire.
3.2. Création d’un script C++
Le script doit afficher une fenêtre qui contient des champs qui permettront de voir et
de modifier les nouveaux attributs. Lorsque l’on clique sur un utilisateur, le script sera
exécuté avec des paramètres dont le type d’objet (utilisateur, domaine, ordinateur…) ainsi
que le nom unique dans l’annuaire LDAP de l’objet sur lequel on a cliqué (exemple :
« LDAP://CN=test,CN=Users,DC=Doubs,DC=fr »). On va alors pouvoir récupérer les valeurs
des attributs dont on a besoin pour remplir les champs de la fenêtre. La mise à jour de ces
attributs sera également possible grâce à ce nom.
Pour lier les utilisateurs du système informatique aux employés de l’annuaire du
service RH, dont la plupart des informations sont les mêmes et donc dupliquées, on souhaite
ajouter deux attributs aux utilisateurs. Les attributs qui seront utilisés existe déjà mais ne
sont pas utilisés, il s’agit des attributs ‘employeeId’ et ‘employeeNumber’. On utilisera
‘employeeId’ pour stocker le numéro de matricule d’un employé, numéro que le service des
ressources humaines utilise dans son logiciel. L’attribut ‘employeeNumber’ sera quant à lui
utilisé pour stocker un code correspondant à une liste de droits.
Pour mémoriser la liste de droits que possède un utilisateur parmis les cinq possibles,
on va utiliser un entier qui représente un octet dont chaque bit est assigné à un droit.
Exemple d’un utilisateur qui ne possède aucun droit, son attribut ‘employeeNumber’ a pour
valeur 0.
19
Un utilisateur qui possède le 3e droit aura le 3
e bit de contrôle à 1 et son attribut
‘employeeNumber’ aura donc la valeur de l’octet en base 10, soit 4.
Un utilisateur possédant tous les droits verra chacun des cinq bits de contrôle à 1 et donc son
attribut prendra la valeur 31.
De cette manière, toutes les combinaisons possibles de droits se voient attribuer une
valeur comprise entre 0 et 31.
La fenêtre affichée par le script lors d’un clic sur le menu ‘propriétés’ doit donc faire
apparaître deux champs qui contiennent les valeurs des attributs ‘employeeId’ et
‘employeeNumber’ de l’utilisateur ainsi que des cases à cocher correspondant aux droits
possibles. Lorsque des cases sont cochées ou décochées, la valeur du code est mise à jour.
On pourra donc modifier directement l’attribut ‘employeeId’ et cocher/décocher les droits
de cet utilisateur. La valeur du champ ‘employeeNumber’ sera modifiée automatiquement.
Fenêtre permettant l’accès aux champs ‘employeeId’ et ‘employeeNumber’
20
Pour accéder aux informations de l’utilisateur sur lequel on a cliqué, le script utilise
des informations comme le nom des attributs. Afin de facilité d’éventuelles modifications
(comme par exemple le choix de l’attribut utilisé pour stocker le numéro de matricule), il est
intéressant d’utiliser un fichier externe. Le fait de stocker ces informations dans un fichier
permettra de les modifier sans avoir à modifier le code source et recompiler l’application.
La fenêtre de base utilisera les attributs ‘employeeId’ et ‘employeeNumber’ d’un
utilisateur AD. Si dans le futur, on décide d’utiliser un autre attribut pour une raison ou pour
une autre, il faudra simplement modifier le fichier d’initialisation.
La fenêtre affiche également une liste de droits que l’on peut ajouter à l’utilisateur,
de la même manière, ces droits seront initialisés dans le fichier pour faciliter leur
modification.
3.3. Problèmes rencontrés
Un des problèmes que j’ai rencontré durant le développement de ce programme est
la récupération des informations par LDAP. En effet, les types d’objets et les fonctions
nécessaires sont souvent mal documentés et possèdent des noms souvent compliqués. Par
exemple, l’objet représentant un utilisateur du domaine est de type « IID_IADsUser ».
Un des points qui a généré des erreurs lors du développement a été la conversion de
chaînes de caractères. En effet, chaque fonction à quasiment son propre format de chaîne,
ainsi, tout au long du script j’ai dû jongler entre wchar_t, BSTR, V_BSTR, et AnsiString.
Le dernier point qui m’a posé quelques problèmes était l’utilisation du type
« VARIANT ». A la base, C++ est un langage typé, ce qui signifie que toute variable à un type
bien précis qui est défini lors de la déclaration, cependant, pour les besoins de ses produits,
Microsoft a créé un type d’objet pouvant stocker des variables de différents types. Les
Variants sont un peu compliqués à utiliser, ils sont destinés à être utilisés pour stocker des
objets de types différents mais ils possèdent tout de même un attribut qui définit le type de
l’objet stocké. Leur utilisation a nécessité un certain temps de compréhension.
21
C. Bilan
Le travail que j’ai réalisé au sein de ce projet m’a permis d’acquérir un certain
nombre de compétences et ouvre les portes à la création de nouveaux programmes ou
scripts en rapport avec le service des ressources humaines.
1. Compétences acquises
Ce projet a nécessité qui j’acquière une bonne compréhension du fonctionnement
d’Active Directory et de LDAP. Grâce aux explications de mes collègues de bureau, aux
manuels officiels de Microsoft que m’ont été fournis, et à la documentation trouvée sur
internet, j’ai pu comprendre le fonctionnement de ce système d’informations.
De plus, ce travail m’a permis d’utiliser le langage C++ pour créer une interface
graphique, ce qui m’a fait découvrir le logiciel C++ Builder que je ne connaissais pas.
La partie du programme concernant la manipulation d’un octet pour stocker
plusieurs informations m’a fait travailler sur l’algorithmique et l’optimisation de code. J’ai
notamment appris à manipuler un octet pour y stocker plusieurs informations.
2. Evolutions possibles
Il est possible d’étendre le schéma Active Directory ou de le modifier de manière
illimitée. Le travail réalisé pour ajouter les informations du service des ressources humaines
au schéma AD peut très bien être mis en place pour un autre service. Le service de gestion
financière pourrait bénéficier d’un lien similaire.
Une fois des informations comme le numéro de matricule d’un salarié enregistré
dans l’annuaire AD, on peut très bien imaginer la création de scripts d’automatisation de
certaines tâches. Les objets LDAP étant récupérable au travers de fonctions PHP, des
applications web pourront dorénavant être développés pour les autres services (envoi des
payes, gestion des commandes de fournitures, etc…).
22
III. Projet de gestion des tâches récurrentes
A. Présentation du sujet
B. Travail Réalisé
C. Bilan
23
III. Projet de gestion des tâches récurrentes
Ce projet concerne le développement d’un outil destiné aux administrateurs
système. Cet outil devrait aider les agents à effectuer la vérification des tâches récurrentes
effectuées par les serveurs pendant la nuit.
A. Présentation du sujet
Tous les jours, les agents doivent résoudre les problèmes qui ont eu lieu pendant la
nuit lors de l’exécution automatique de certaines tâches par les serveurs. Afin de pouvoir
résoudre les problèmes, il est essentiel de pouvoir les détecter de manière efficace. C’est là
qu’intervient ce projet.
1. Contexte
Des tâches récurrentes ont lieux tous les mois, toutes les semaines et mêmes tous les
jours pour certaines d’entre-elles. Les serveurs procèdent en effet à une sauvegarde des
données et des bases de données ainsi qu’a une multitude d’autres opérations pendant la
nuit.
Le premier travail des agents lorsqu’ils arrivent le matin est de vérifier que ces tâches
se sont bien déroulées et dans le cas contraire, les problèmes doivent être résolus le plus
rapidement possible.
Un grand nombre de vérifications peuvent être réalisées, certaines sont très
importantes voire essentielles comme s’assurer qu’aucun disque dur n’arrive à saturation, et
d’autres sont secondaires comme par exemple le fait de vérifier qu’il n’existe pas de version
plus récentes de tel ou tel logiciel. Cependant, même des tâches de moindre importance
peuvent générer des problèmes. En effet, sur un parc informatique de la taille de celui du
Conseil Général du Doubs, même une simple mise à jour peut générer des erreurs impactant
plusieurs dizaines voire centaines d’utilisateurs. De plus, plus la version d’un logiciel à mettre
à jour est obsolète, plus le risque que la mise à niveau pose des problèmes est élevé.
Les problématiques actuelles sont, d’une part, qu’il est difficile pour les agents de
couvrir la totalité des vérifications qu’il faudrait faire, d’autant plus lorsque des erreurs
concernant des tâches importantes sont détectés, et d’autre part, qu’aucun suivi dans le
temps n’est possible en ce qui concerne les tâches qui génèrent des erreurs.
24
2. Objectifs du projet
L’objectif de ce projet est double. Il fournira d’abord la liste des tâches reflétant la
vérification complète que doivent faire les agents tous les matins, et il permettra ensuite
l’obtention d’informations quant aux problèmes détectés.
Cette liste servira de fil conducteur pour les agents et permettra d’avoir une vision
globale de tout ce qui doit être vérifié. Elle devrait permettre à tous les techniciens
d’effectuer la même vérification dans un ordre précis et ainsi d’éviter que certaines tâches
secondaires soient oubliées.
3. Cahier des charges
La liste des tâches de vérifications sera présentée à travers une interface web. On
utilisera une base de données MySql pour stocker les tâches à afficher ainsi que les erreurs
détectées.
La liste contiendra toutes les tâches de fond effectuées par les serveurs qui
nécessitent une vérification.
Elle devra être ergonomique pour permettre aux agents de gagner du temps
lorsqu’ils font leur vérification.
Pour chaque tâche, il doit être possible de signaler un incident, de le décrire, et
d’indiquer l’impact éventuel sur le système ou sur les utilisateurs.
Des e-mails doivent être envoyés aux responsables de l’exploitation informatique
pour les prévenir d’un problème impactant beaucoup d’utilisateurs. Un e-mail de rapport
doit également leur être expédié à la fin de la vérification d’un agent.
La connexion à l’application ne doit être possible que pour les administrateurs
systèmes et les responsables de l’exploitation.
Une rubrique réservée aux responsables doit permettre l’ajout de tâches ou de
catégories, ainsi qu’une liste de toutes les tâches qui ont généré des erreurs afin de faire
apparaître les problèmes récurrents.
L’application devra indiquer quel technicien a effectué la dernière vérification ou
signalé telle ou telle erreur.
25
B. Travail Réalisé
L’application réalisée est de type Web et elle est hébergée sur le domaine doubs.fr.
Une base de données MySql a été mise à disposition pour le stockage des informations.
1. Conception
Afin de remplir ses objectifs, l’application doit être rapide et ergonomique. Une
application PHP et MySql permettra le développement d’une interface simple de gestion
ainsi que le stockage d’informations (comme par exemple la liste des tâches ayant généré
des erreurs).
1.1. L’interface utilisateur
Pour que les agents gagnent du temps lors de la vérification quotidienne, il est
impératif de leur éviter toute navigation inutile. Ainsi, la totalité des tâches sera vérifiée
depuis la même page.
La liste des tâches du jour affiché par l’application lorsqu’un agent se connecte et
générée depuis la liste des tâches ‘modèles’ préalablement enregistrées. Une rubrique,
permettra en effet aux responsables du pôle infrastructure de saisir les tâches récurrentes
qui devront être vérifiées et à quelle fréquence.
1.2. La Base de données
Modèle conceptuel de données
26
La base de données MySql sera composée de quatre tables :
o Catégorie
Les catégories permettront de classer les tâches pour les proposer aux agents dans
un ordre précis.
o Technicien
Chaque agent qui utilise l’application sera enregistré dans la base de données pour
permettre, par exemple, de connaître la personne qui a effectué la dernière vérification ou
qui a signalé telle ou telle erreur.
o Tache
Cette table va contenir toutes les tâches. Il y aura quatre types de tâches stockés ici.
La table contiendra tout d’abord les tâches ‘modèles’, il s’agit de la liste complète des tâches
récurrentes à vérifier. La liste pourra être agrandie par les responsables au fur et à mesure
des besoins. Lorsqu’un agent se connectera à l’application, on va alors créer la liste des
tâches du jour à partir des modèles. C’est ce deuxième type de tâches qui va être visible par
les techniciens lors de leur vérification. Si l’agent ne détecte aucune erreur sur une de ces
tâches, elle sera supprimée de la base de données. En revanche, si une erreur est signalée, la
tâche est conservée et restera affichée jusqu’à sa validation (et donc résolution du
problème). Les tâches ayant généré des erreurs seront conservées dans la base et seront
listées dans une rubrique réservée aux responsables. Cela permettra à ces derniers d’obtenir
un certain nombre d’informations comme notamment le temps pendant lequel une tâche
est restée en erreur.
Pour résumé, la table Tâche contiendra :
� Les tâches « modèles » (attribut ‘estModele’=1):
• Ne sont pas visibles par les agents
• Sont quotidienne, hebdomadaires ou mensuelles.
� Les tâches du jour (‘estModele’=0 et ‘dateTache’=<date du jour>) :
• Sont des copies des tâches modèles auxquelles on ajoute la
date du jour
• Sont créées à la connexion d’un agent selon la fréquence
du modèle et la date de la dernière connexion
• Sont éditées par les agents (validation ou description de
l’erreur)
• Sont supprimées de la base si validée sans erreur
� Les tâches en erreur (‘erreurSignalee’=1) :
• Sont obligatoirement décrites et leur impact indiqué
27
• Reste affichées tant que non-validées
� Les tâches validées après erreur (‘erreurSignalee’=0,
‘dateValidation’=<…>)
• Sont listées pour les responsables
• Voient leur attribut ‘dateTache’ comparé à ‘dateValidation’
pour connaître la durée de l’erreur
o Connexion
Les connexions à l’application seront également stockées dans la base de données.
Lorsqu’un utilisateur va se connecter à l’application, cette table permettra notamment de
savoir quelles sont les tâches du jour. Les tâches quotidiennes ne seront proposées que lors
de la première connexion de la journée, les tâches hebdomadaires lors de la première
connexion de la semaine, etc… De cette manière, si deux agents se connectent à
l’application, les tâches à vérifiés ne seront ajoutées qu’une fois.
2. Fonctionnalités
2.1. Connexion LDAP
L’application de gestion des tâches récurrentes ne doit être accessible que par
certaines personnes. De plus, on doit connaître l’agent qui a signalé une erreur sur une
tâche, ou encore le nom du dernier technicien ayant effectué la vérification. Une
authentification doit donc être mise en place et les utilisateurs doivent être enregistrés dans
la base.
Pour éviter aux techniciens d’avoir à saisir un identifiant et un mot de passe à chaque
connexion, l’application utilise l’authentification Windows. En effet, lorsqu’un utilisateur
souhaite accéder à une page de l’application, cette dernière va avant tout vérifier que
l’utilisateur est authentifié. Si ce n’est pas le cas, il est automatiquement redirigé vers une
page de connexion. Cette page va interroger l’annuaire Active Directory grâce à une requête
LDAP pour connaître le nom complet de l’utilisateur courant à partir de son identifiant
Windows. Elle va également récupérer le groupe de l’utilisateur pour vérifier qu’il fait bien
partie des administrateurs système.
Si l’utilisateur fait partie des administrateurs, il est connecté et redirigé vers la page
principale de l’application automatiquement, sinon un message d’erreur apparaît. Les
utilisateurs sont enregistrés dans la base de données lors de leur première connexion.
Avec ce mode de fonctionnement, la connexion à l’application est totalement
transparente pour l’utilisateur.
28
2.2. Liste des tâches
Lors de chaque connexion d’un agent, la date est enregistrée dans la base de
données. A chaque nouvelle connexion, l’application va comparer la date actuelle à la date la
plus récente dans sa base de données (date de la dernière connexion). Si le mois a changé
depuis la dernière connexion, les tâches modèles dont la fréquence est mensuelle sont
dupliquées, on passe leur attribut ‘estModèle’ à zéro, et on leur attribue la date du jour. Ce
sont ses tâches qui seront affichées pour la vérification de l’agent. De la même manière, si
une semaine est passé depuis la dernière connexion, on ajoute les tâches hebdomadaire et
idem pour les tâches quotidienne.
Lorsque l’agent accède à l’application, il arrive donc sur la liste des tâches à vérifier,
triées par catégorie. Pour chaque tâche, il effectue la vérification correspondante, s’il n’y a
pas d’erreur il valide la tâche qui disparaît de la liste et est supprimée de la base de données.
Si au contraire une erreur est détectée, il doit saisir une description de l’erreur dans un
champ prévu à cet effet. Il peut également préciser si l’erreur à un impact sur le système ou
sur les utilisateurs. S’il y a un impact sur les utilisateurs, il peut signaler le nombre
d’utilisateurs touchés et s’il signale que plus de 200 utilisateurs sont impactés, un email est
envoyé automatiquement aux responsables du pôle.
2.3. Envois d’emails
Comme c’est évoqué dans le paragraphe précédent, l’application envoi des emails
automatiquement. En effet, si un agent signale qu’une tâche ne s’est pas déroulée
correctement et qu’elle génère une erreur impactant plus de 200 utilisateurs, les
responsables du pôle infrastructure reçoivent automatiquement un email. Ce courrier leur
précise quelle tâche à générer l’erreur et quel technicien l’a signalé.
De plus, un bouton apparaît à la fin de la vérification pour permettre d’envoyer un
rapport aux responsables. Ce rapport les informe de qui a effectué la vérification et il leur
donne la liste de toutes les tâches en erreur ou qui n’ont pas été traitées par l’agent.
2.4. Gestion des tâches et catégories
Les listes de tâches ‘modèles’ et de catégories vont être enregistrées lors de la mise
en production de l’application. Cependant, les responsables du pôle ont la possibilité
d’ajouter, modifier ou supprimer des tâches et des catégories grâce à des formulaires
simples.
29
Formulaire d’ajout d’une tâche
Formulaire d’ajout d’une catégorie
2.5. Tâches ayant généré des erreurs
Cette rubrique, réservée aux responsables, liste la totalité des tâches ayant été
validées après avoir été en erreur. En effet, lorsqu’un agent signale une erreur sur une tâche,
cette dernière reste affichée jusqu’à ce que le problème soit résolu et la tâche validée. Cette
liste permet de connaître quelles tâches génèrent souvent des erreurs ou quelles tâches sont
restées en erreurs le plus longtemps.
Cette fonctionnalité apportera des informations sur plus long terme, qui n’étaient pas
disponible auparavant. Constater qu’une certaine tâche pose fréquemment problème
pourrait permettre de détecter des erreurs dont on n’avait pas connaissance. De la même
manière, d’éventuels liens entre plusieurs erreurs pourront être mis en évidence grâce à
cette liste et ainsi faciliter leur résolution.
30
3. Ergonomie
Afin de garantir une vérification la plus rapide possible, l’application ce doit d’être le
plus ergonomique possible.
La liste des tâches affichées doit apparaître dans un ordre précis car certaines
vérifications dépendent de la réussite d’une autre tâche. De plus, chaque tâche a une
catégorie qui lui est attribué pour permettre de regrouper les tâches similaires. Ainsi, les
tâches seront présentées au technicien par groupes. Lorsque l’agent a effectué toutes les
vérifications d’une catégorie, il passe à la suivante en cliquant sur un bouton.
Pour que la page ne soit pas rechargée lorsqu’un agent passe d’une catégorie à une
autre, l’application utilise Javascript. En effet, la totalité des catégories est affichée sur la
page mais elles sont toutes invisibles sauf la première. Lorsque l’utilisateur clique sur le
bouton ‘suivant’ ou ‘précédent’, l’application masque la catégorie affichée et rend visible la
suivante.
Lorsqu’un utilisateur valide une tâche ou signale une erreur, une page de traitement
est appelée et elle enregistre les modifications dans la base de données. Une fois les
requêtes à la base effectuées, on redirige l’utilisateur sur la liste des tâches. La dernière
catégorie visitée est donc enregistrée pour permettre à l’utilisateur de reprendre la
vérification là où il en était. De cette manière, le traitement est totalement transparent pour
l’utilisateur. Si la tâche a été validée, elle est supprimée, sinon si une erreur a été signalée, la
tâche n’est pas supprimée mais la ligne du tableau est colorée en rouge. Dans tous les cas,
l’utilisateur reste au même endroit sur l’application.
4. Difficultés rencontrées
Pour garantir une vérification rapide des agents, il est essentiel d’afficher toutes les
tâches en une fois pour éviter des chargements durant la saisie. Cependant, dans un souci
d’ergonomie et pour garantir l’ordre de vérification des tâches, il est pertinent de regrouper
les tâches par catégorie. C’est donc grâce à Javascript que l’on va masquer les catégories et
n’en afficher qu’une à la fois. Or, chaque action des agents (validation d’une tâche ou
signalement d’erreur) provoque une écriture dans la base de données. L’affichage des
données et l’exécution des traitements étant faits par des pages différentes, la difficulté
principale de ce projet a été de réussir à effectuer les requêtes à la base de données de
manière transparente pour l’utilisateur.
Lorsque la page listant les tâches du jour est chargée, c’est la première catégorie qui
est affichée, lorsque l’utilisateur effectue une action, c’est une page de traitement qui fait
les requêtes à la base de données, puis il y a une redirection automatique pour renvoyer
l’agent sur la liste des tâches. Pour que le traitement soit transparent pour l’utilisateur, il a
31
été nécessaire d’ajouter une action lors de l’exécution des traitements. La variable
$_SESSION en PHP permet de stocker une liste d’attribut accessible par toutes les pages. J’ai
donc utilisé cette variable pour stocker un attribut ‘idCat’ avant chaque traitement. De cette
manière, lorsque l’utilisateur va être redirigé sur la liste des tâches après un traitement,
l’application sait quelle catégorie était visitée et elle l’affiche au lieu de la première. Ainsi
l’application bénéficie à la fois d’une bonne ergonomie grâce à l’affichage par catégorie,
d’une certaine efficacité grâce à la séparation des pages d’affichage et des pages de
traitements, et elle permet un gain de temps important grâce à une navigation automatisée.
Une autre manière de faire gagner du temps aux agents a été de remplacer le
système d’authentification classique (login + mot de passe) par une connexion automatique
utilisant LDAP. En effet, les utilisateurs du réseau étant obligatoirement authentifiés sur le
domaine, il est possible de se connecter par PHP à l’annuaire grâce à LDAP et d’effectuer des
requêtes pour récupérer les informations que l’on cherche. Pour obtenir les informations de
l’utilisateur qui se connecte, il est nécessaire de connaître son nom dans Active Directory.
Pour obtenir ce nom sans que l’utilisateur soit obligé de le saisir manuellement, les
paramètres d’authentification au site web ont dû être modifiés. En effet, en configurant le
site pour une authentification par Windows, c’est le nom de la session Windows (en
l’occurrence leur nom dans l’annuaire AD) qui va être utilisé. On effectue alors une requête
pour connaître l’attribut ‘distinguishedName’ de l’utilisateur qui tente de se connecter. Cet
attribut est le nom unique et complet d’un utilisateur dans l’annuaire. Il est stocké sous la
forme d’une chaîne qui contient le chemin d’accès à l’objet depuis la racine du domaine (ex :
« LDAP://CN=Jean-Marc Dupont, CN=Users, DC=Doubs, DC=fr »). Sachant que cette
application est réservée aux administrateurs système du pôle Infrastructure, on va devoir
vérifier que la personne qui essaye d’accéder à l’application fasse bien partie des groupes
« Pôle Infrastructure » et « Administration Système ». L’idée est donc de tester si il existe
une sous-chaîne « OU=Administration Système, OU=Pôle Infrastructure » dans le
‘distinguishedName’ de l’utilisateur. En exemple, voici le ‘distinguishedName’ de mon
compte utilisateur :
CN=Petracca Charlélie, OU=Administration Système, OU=Pôle Infrastructures, OU=SSI - Service des
systèmes d'information, OU=DSIPL - Direction Systèmes d'Information Pilotage Logistique, OU=DGA-
PAR - Pôle Administration et Ressources, OU=Doubs, DC=doubs, DC=fr
On constate la présence de la sous-chaîne « OU=Administration Système, OU=Pôle
Infrastructures », ce qui m’autorise l’accès à l’application.
Enfin, le dernier point qui m’a posé quelques problèmes est le navigateur internet
installé sur les machines. En effet, le navigateur utilisé est Internet Explorer 6 et il est donc
incompatible avec un grand nombre de fonctionnalités HTML 5, CSS 3, et Javascript. Cela a
rendu la partie ergonomie plus difficile à développer.
32
C. Bilan
Le travail que j’ai réalisé au sein de ce projet m’a permis de conforter mes
compétences dans le domaine du web et d’en acquérir des nouvelles. De nombreuses
évolutions peuvent être envisagées, ce projet servant de base répertoriant la liste complète
des tâches à réaliser.
1. Compétences acquises
Pour réaliser ce projet, j’ai dû comprendre le fonctionnement de base du protocole
LDAP ainsi que des fonctions PHP permettant la connexion et l’exécution de requêtes.
J’ai aussi du réalisé une application ergonomique et j’ai donc appris à utiliser JQuery
(Bibliothèque de fonctions Javascript) et AJAX (Technologie de requêtes asynchrones au
serveur, permettant notamment au serveur d’effectuer des traitements sans recharger la
page web).
De plus, au sein du Conseil général, une application de ce type, à de fortes chances
d’être un jour améliorée ou modifiée. Pour cette raison il est essentiel de produire un code
propre et bien commenté en gardant toujours à l’esprit que quelqu’un devra très
probablement travailler dessus un jour ou l’autre.
2. Evolutions possibles
L’application a été conçue pour permettre d’ajouter ou supprimer des tâches et
catégories. Cela devrait permettre de l’utiliser un maximum de temps sans avoir à modifier
le code source. On peut cependant imaginer divers évolutions comme la génération de
graphs concernant les tâches qui ont généré des erreurs. Des tableaux de statistiques
pourraient être ajoutés à l’application pour permettre de mieux cibler les problèmes.
Le graphisme de cette application peut être amélioré. En effet, la consigne que j’ai
suivie était de me concentrer sur l’aspect fonctionnalités, l’application étant destinée à un
public technique. Une partie de mon travail à quand même concerné le graphisme mais
seulement ce qui était essentiel au bon fonctionnement de l’application. Une grosse
évolution graphique pourra par exemple être effectuée lorsque la version du navigateur
internet actuellement installée sera mise à jour.
33
IV. Travaux sur le monitoring
A. Le monitoring
B. Objectifs
C. Travaux réalisés
D. Évolutions possibles
34
IV. Travaux sur le monitoring
Un travail intéressant que j’ai dû réaliser lors de ce stage concernait la récupération
de données concernant les événements des calendriers Outlook des utilisateurs.
A. Le monitoring
On appelle le monitoring la collecte d’informations sur les plateformes de production
du système d’informations. Au sein du pôle infrastructure, on utilise le monitoring pour
s’assurer de la disponibilité réelle des serveurs distants, ou encore pour afficher si un disque
arrive à saturation, cela permet aux agents de détecter les problèmes dès qu’ils
interviennent.
B. Objectifs
Un projet est actuellement en cours de développement pour afficher sur les écrans
de contrôle d’autres informations comme l’état des bases de données, de l’anti-virus ou
encore du pare-feu. L’objectif qui m’a été donné est de récupérer les évènements d’un
calendrier Microsoft Outlook. En effet, les agents utilisent ce logiciel pour la gestion de leurs
emails et de leur emploi du temps.
L’objectif est donc de pouvoir afficher un block contenant les prochains rendez-vous
importants sur les écrans.
C. Travail réalisé
La difficulté de ce travail est que les données ne peuvent pas être récupérer
directement depuis le logiciel Outlook. En effet pour obtenir les données, il est impératif de
se connecter directement au serveur Exchange (le serveur de messagerie).
C’est grâce à un petit projet trouvé sur internet après de longues recherches que j’ai
réussi à récupérer les évènements. En effet ce projet nommé « php-ews » (exchange web
services) contient un ensemble de classes PHP correspondant à tous les types d’objet utilisé
par le serveur de messagerie. Après avoir spécifié toutes les caractéristiques de l’objet que
l’on cherche, on peut effectuer une requête directement sur le serveur et ainsi récupérer par
exemple tous les évènements compris entre deux dates.
Pour chaque évènement extrait de cette manière, on va obtenir des attributs comme
la date de début, la date de fin, le sujet ou encore le lieu du rendez-vous. Ainsi on peut créer
le block qui sera affiché sur l’écran de contrôle.
35
Pour les événements ayant lieu dans la journée, on va calculer le temps restant avant
le rendez-vous, et grâce à Javascript, on va afficher un compteur pour une meilleure
visibilité.
Block qui sera affiché sur les écrans de contrôle. Il liste les événements à venir pour les
deux prochaines semaines.
D. Evolutions possibles
Ce projet pourrait être utilisé autrement que pour du monitoring. On peut
effectivement envisager la création de tableaux de bord pour les agents. En saisissant leurs
actions dans leur calendrier Outlook, les agents pourraient facilement obtenir des
statistiques sur leur travail. Le fait de connaître le temps que passent les techniciens sur
telles ou telles tâches dans leur travail quotidien permettrait de détecter celles qui sont les
plus chronophages et donc de définir des priorités précises quant aux points à améliorer.
36
Conclusion Générale
Ce stage a été une expérience très enrichissante pour plusieurs raisons. Le fait
d’effectuer mon stage au sein d’une équipe d’administrateur système m’a permis de
découvrir une facette de l’informatique que je ne connaissais pas ou très peu. Même lors de
mes travaux de développement, mes collègues ont pu me donner divers explications et
conseils qui m’ont beaucoup apportés. En effet, travailler dans un milieu « système » m’a
apporté beaucoup de connaissances sur des points que je ne maîtrisais pas comme
l’allocation de mémoire ou encore l’optimisation du code pour plus d’efficacité au niveau de
la compilation. Je considère ce stage comme une réussite puisque j’ai appris beaucoup
pendant cette période grâce notamment à une équipe toujours disponible pour m’aider
dans mon travail et pour prendre du temps pour m’expliquer certain aspect de leur métier.
Pour ma part, j’ai réussi à mettre à profit mes compétences pour développer des
applications qui seront réellement utilisées et qui permettront aux agents de gagner du
temps dans leur travail (application de gestion des tâches). De plus, mon travail ouvre les
portes à divers évolutions qui permettront d’augmenter l’efficacité du CG dans certaines
tâches (Liaison de l’informatique au service RH).
Ce stage va déboucher sur un contrat d’été pendant lequel je vais travailler sur la
refonte de certains scripts (notamment les scripts d’ouverture de session par les
utilisateurs). Cela me permettra d’ajouter encore quelques connaissances dans le domaine
du système.
37
Annexes
1. Microsoft Active Directory
2. Le protocole LDAP
3. Script C++ du projet d’extension de la MMC
38
Annexe 1 - Microsoft Active Directory
Active Directory sépare les structures logique et physique du domaine.
Structure logique :
Ensemble des éléments intangibles (objets, domaines, arbres et forêts).
Structure physique :
Ensemble des contrôleurs et sites de domaine.
Composants physiques Description
- Magasin de données Fichier sur chaque contrôleur de domaine
qui stocke les informations AD.
- Contrôleur de domaine Contient des copies de la BDD AD.
- Serveur de catalogue global Copie partielle des objets de la forêt qui
permet d’accélérer les recherches d’objets.
- Contrôleur de domaine en lecture seule (RODC)
Installation spéciale d’AD dans une forme de
lecture seule.
Composants logiques Description
- Partitions Appelées aussi contextes d’appellation, il
s’agit d’une section de la BDD.
- Schéma Définit la liste des types d’objets et
d’attributs.
- Domaines Limite d’administration logique pour les
utilisateurs et les ordinateurs.
- Arborescences de domaines Collection des domaines possédant un
domaine racine commun
- Forêts Collection de domaines partageant un
service AD commun.
- Sites Collection d’utilisateurs, groupes et
ordinateurs.
- Unités d’organisation (OU) Conteneurs dans AD
39
Annexe 2 - Protocole LDAP
1. Protocole
LDAP est un protocole d’annuaire standard et extensible. C’est une interface
normalisée qui permet d’accéder de façon standard aux différents services de l’annuaire.
Il fournit :
- Le protocole permettant d’accéder à l’information contenue dans l’annuaire,
- Un modèle d’information qui définit le type de données contenues dans
l’annuaire,
- Un modèle de nommage qui définit comment l’information est organisée et
référencée,
- Un modèle fonctionnel qui définit comment on accède à l’information,
- Un modèle de sécurité qui définit comment les données sont protégées,
- Un modèle de duplication qui définit comment la base est répartie entre
serveurs.
Le protocole définit comment s’établit la communication client-serveur. Il fournit à
l’utilisateur des commandes pour se connecter ou se déconnecter, pour rechercher,
comparer, créer, modifier ou effacer des entrées.
2. Modèle de données
Les données LDAP sont structurées dans une arborescence hiérarchique dont chaque
nœud correspond à une entrée de l’annuaire.
Les entrées correspondent à des objets réels ou abstraits, comme une personne, une
imprimante, ou des paramètres de configuration. Chacune de ces entrées contient un
certain nombre d’attributs.
L’ensemble des objets est défini par le schéma. Ce dernier décrit les classes d’objets,
leurs types d’attributs et leur syntaxe. Il définit les éléments suivants :
- Les objets qui sont utilisés pour stocker les données dans l’annuaire,
- Les règles qui définissent quels types d’objet on peut créer, et quels attributs
(obligatoire ou non) doivent être définis,
- La structure et le contenu de l’annuaire lui-même.
40
Les attributs de chaque entrée sont caractérisées par :
- Un nom,
- Un Object Identifier (OID) qui l’identifie,
- Contient-il plusieurs valeurs ?
- Une syntaxe et des règles de comparaison,
- Un indicateur d’usage,
- Un format ou une limite de taille.
Ils décrivent les caractéristiques de l’objet et sont accessible aux utilisateurs. Certains
attributs, dits opérationnels, ne servent qu’au serveur pour administrer les données.
Les classes d’objets modélisent des objets en les caractérisant par une liste
d’attributs obligatoires ou non. Elle est définit par :
- Un nom,
- Un OID,
- Des attributs obligatoires,
- Des attributs optionnels,
- Un type (structurel, auxiliaire ou abstrait).
Un type de classe est lié à la nature des attributs qu’elle utilise.
- Une classe structurelle correspond aux objets basiques de l’annuaire
(personnes, groupes...),
- Une classe auxiliaire désigne des objets qui ajoutent des informations
complémentaires aux objets structurels (Ex : objet mailRecipient, qui rajoute
les attributs concernant la messagerie électronique d’une personne),
- Une classe abstraite désigne des objets basiques de LDAP comme les objets
top ou alias.
Les classes d’objets forment une hiérarchie, au sommet de laquelle se trouve l’objet top.
Chaque objet hérite des propriétés (attributs) de l’objet dont il est le fils. La classe de l’objet
est précisée à l’aide de l’attribut objectClass. Une entrée peut appartenir à plusieurs classes
d’objet.
41
3. Modèle fonctionnel
Voici la liste des principales opérations que LDAP peut effectuer :
Opération Description
Abandon Abandonne l'opération précédemment envoyées au serveur
Add Ajoute une entrée au répertoire
Bind Initie une nouvelle session sur le serveur LDAP
Compare Compare les entrées d'un répertoire selon des critères
Delete Supprime une entrée d'un répertoire
Extended Effectue des opérations étendues
Rename Modifie le nom d'une entrée
Search Recherche des entrées d'un répertoire
Unbind Termine une session sur le serveur LDAP
Les opérations Search et Compare se font sous la forme d’une requête composée de
8 paramètres :
Paramètres Description
Base object Endroit de l’arbre où doit commencer la
recherche
Scope Profondeur de la recherche
DerefAliases Suit-on les liens ?
Size limit Nombre limite de réponses
Time limit Durée maximum de la recherche
AttrOnly Renvoie-t-on la valeur des attributs ?
Search filter Filtre de recherche
List of attributes Liste des attributs que l’on veut connaître
42
Les filtres sont exprimés sous forme d’expressions régulières désignant un ou
plusieurs objets de l’annuaire. Les opérateurs de recherche disponibles sont :
- Egalité : =
- Approximation : ~=
- Comparaison : <, <=, >, >=
- Présence : =*
- Sous-chaîne : *<expression>*
- ET, OU : (&(<expression>)(<expression>))
- Négation : !(<expression>)
43
Annexe 3 - Script C++ du projet d’extension de l’Active Directory
Cette annexe est constituée de parties du code concernant des points importants du
script.
- Déclaration des masques représentant les droits d’un utilisateur
byte B_TYPE = 1; byte B_INTERNE = 1 << 1;
byte B_RESPONSABLE = 1 << 2; byte B_ADJOINT = 1 << 3;
byte B_SECRETARIAT = 1 << 4;
Le symbole “ << x ” signifie que l’on déplace le bit de x sur la gauche. 1<<1 devient
donc 2 car l’octet passe de 00000001 à 00000010. De la même manière, 1<<2 devient 4 car
l’octet passe de 00000001 à 00000100. Ainsi, chacun de ces 5 droits sont assignés à un bit
différent.
- Cocher les checkbox selon la valeur de l’attribut ‘employeeNumber’
//pour savoir quels sont les droits que possède un utilisateur // on va tester la valeur de son attribut et vérifier si les bits // correspondant à chaque droit sont positionnés sur 1 if (employeeNumber & B_TYPE)
checkbox_type -> checked = true ;
if (employeeNumber & B_INTERNE) checkbox_int -> checked = true ;
if (employeeNumber & B_RESPONSABLE) checkbox_resp -> checked = true ;
…
Par exemple, si la valeur de l’attribut ‘employeeNumber’ d’un employé est 6. En
base 2, cette valeur sera donc 00000110. Pour chaque droit, on veut vérifier si le bit
correspondant est à positionné à 1 sur l’octet 00000110 et donc si l’utilisateur possède le
droit.
En utilisant l’opérateur ‘&’ (ET), entre ‘employeeNumber’ et ‘B_TYPE’, on test en fait
le résultat de 00000110 & 00000001. Le résultat est 00000000 ce qui veut dire que
l’utilisateur ne possède pas ce droit. Le test avec ‘if’ retournera ‘False’ et la case ne sera pas
cochée.
44
Pour le droit ‘B_INTERNE’, l’opération sera 00000110 & 00000010. Le résultat est
00000010, il est positif et donc ‘True’. L’utilisateur possède donc ce droit.
On va répéter ce test pour chacun des droit et on pourra ainsi déduire quels sont les
droits d’un utilisateur par rapport à la valeur de son attribut ‘employeeNumber’.
- Mise à jour de l’attribut employeeNumber selon les cases cochées
//calcule la valeur de l’attribut ‘employeeNumber’ selon les cases cochées void UpdateEmpNb(void) { int number = 0;
if(RadioButton2->Checked)
number |= B_TYPE; if(RadioButton4->Checked) number |= B_INTERNE;
if(CheckBox3->Checked) number |= B_RESPONSABLE;
if(CheckBox4->Checked) number |= B_ADJOINT; if(CheckBox5->Checked)
number |= B_SECRETARIAT;
Edit2->Text = IntToStr(number); }
Pour l’opération inverse, c’est-à-dire trouver la valeur de l’attribut selon les cases qui
sont cochées, la fonction ‘UpdateEmpNb’ sera appelé à chaque fois qu’une case est cochée
ou décochée.
Pour chaque droit, on va ajouter le bit de contrôle correspondant à la valeur de
l’attribut grâce à l’opérateur ‘|’ (ou exclusif).
De cette manière, à chaque fois qu’une case est cochée ou décochée, la valeur de
l’attribut est calculée et mis à jour dans la fenêtre.
45
- Récupération des attributs de l’objet User de l’Active Directory
// déclaration des variables et initialisation des Variants IADsUser *pUser=NULL; VARIANT var, var2 ;
VariantInit(&var); VariantInit(&var2); // récupération des paramètres passés à l'application (nom de l’utilisateur) user = ParamStr(1);
// conversion vers wchar_t size = user.WideCharBufSize() ;
util = new wchar_t[size] ; user.WideChar(util,size);
// connexion à l’objet User de l’AD hr = ADsGetObject ( util , IID_IADsUser , (void**)&pUser) ;
if (hr != S_OK) {
//traitement de l’erreur }
// recuperation des attributs nécessaires pUser -> Get( CComBSTR( attr1.c_str() ) , &var );
if (hr != S_OK) { //traitement de l’erreur } pUser -> Get( CComBSTR( attr2.c_str() ) , &var2 );
if (hr != S_OK) { //traitement de l’erreur }
// affichage des attributs champMatricule -> Text = V_BSTR(&var); champDroits -> Text = IntToStr( V_I4(&var2) ) ;
// libération des ressources VariantClear(&var) ; VariantClear(&var2) ;
delete (util);
Cette partie du code sert à afficher la valeur des attributs de l’utilisateur sur lequel on
a cliqué. La première étape consiste à se connecter à l’AD pour récupérer l’objet User grâce
à la fonction ‘ADsGetObject’ à laquelle on donne en paramètres le nom de l’objet que l’on
cherche, le type de l’objet et la variable dans laquelle on souhaite stocker l’objet.
46
On peut ensuite récupérer les attributs que l’on veut grâce à la fonction ‘Get’ (en
l’occurrence le numéro de matricule stocké dans l’attribut ‘employeeID’ et le code des droits
stocké dans ‘employeeNumber’). Les valeurs de ces attributs sont stockées dans des
variables de type VARIANT. Lorsque l’on veut utiliser ces Variants, il est nécessaire d’indiquer
le type de valeur qu’ils contiennent (du texte pour le numéro de matricule, une valeur
entière pour le code des droits).
47
Lexique
Adresse MAC : Identifiant physique d’une interface réseau.
Annuaire électronique : Type de base de données permettant de stocker, de
rechercher, de trier ou d’organiser des informations.
Attributs : Caractéristiques de l’objet dans l’annuaire.
Arbre AD : Ensemble de domaines parents qui permet le partage de
ressources. Un arbre peut n’être composé que d’un seul
domaine.
Catalogue global : Il contient un réplica partiel de chacun des domaines de
l’annuaire. Il permet à l’utilisateur du trouver des objets en
spécifiant un ou plusieurs de ses attributs.
Classe : Groupements logiques d’objets (Ex : Utilisateurs, Groupes,
Ordinateurs, etc…).
DNS : Domain Name System. Service permettant de traduire des
noms de domaines en adresses IP et inversement.
Domaine (ou partition) : Regroupe des objets apparentés ensemble afin de refléter le
réseau de l’organisation (Ex : societe.com, sous-
domaine.societe.com, etc…).
Forêt AD : Au niveau le plus élevé, des arbres disparates peuvent être
regroupés pour former une forêt. Tous les arbres d’une forêt
partagent le même schéma.
Identificateur global unique : Chaque objet du réseau doit être identifié par une propriété
unique. Active directory associe donc un identificateur global
unique (GUID) à chaque objet.
LDAP : Protocole TCP/IP permettant l’interrogation et la modification
des services d’annuaire.
Monitoring : Le monitoring est une activité de surveillance et de mesure
d’une activité informatique (mesure de performance, de
disponibilité, d’intégrité…).
48
Objet : Ressource réseau. Peut être organisé en classes. Des objets
peuvent en contenir d’autres, on les appelle Feuilles et
Conteneurs (un conteneur peut contenir des feuilles et d’autres
conteneurs).
Schéma : Définition formelle de tous les types d’objets d’un arbre. Il peut
être modifié pour définir les attributs qui doivent être stockés
dans le catalogue global.
Unité d’organisation (OU) : Type de conteneur utilisé fréquemment pour catégoriser les
objets d’un domaine.
49
Bibliographie
Pour réaliser mes projets j’ai utilisé plusieurs sources.
Documentation Microsoft en ligne :
http://technet.microsoft.com/
http://msdn.microsoft.com/
Documentation PHP en ligne :
http://www.php.net/
Documentation JQuery en ligne :
http://jquery.com/
Tutoriaux et cours en ligne :
http://www.developpez.com/
http://fr.openclassrooms.com/
Forums d’entraide :
http://stackoverflow.com/
50
Rapport de stage de Licence professionnelle par Charlélie Petracca.
La Licence professionnelle SIL Conception et développement orientés objets
d’applications multi-tiers se classe plutôt dans le domaine de la programmation. Cependant
c’est dans une équipe d’administrateurs réseau et système que j’ai effectué mon stage de fin
d’année. De ce fait, ce stage a été d’autant plus intéressant, j’ai en effet pu apprendre
beaucoup dans des domaines que je ne connaissais que très peu. J’ai également pu mettre à
profit mes compétences de développeur pour réaliser plusieurs projets qui seront utilisés
par cette équipe.
Mots clés :
Active Directory - Administration système - Annuaire informatique - Développement web -
Evènements Outlook - LDAP - Scripting
Internship Report of Professional license by Charlélie Petracca.
The professional license “Computer systems and software, object-oriented multi-tier
software development” could be categorized in the field programming. However, it’s in a
team of system and networks administrators that I’ve done my internship. That’s why this
work placement was quite interesting. Indeed, I learned many things in fields that I hardly
knew. I was also able to use my developer skills for various projects that will be used by the
team.
Key words :
Active Directory - System administration - IT Directory - Web development - Outlook events -
LDAP - Scripting