Les 20 commandements de l’intégration

logicielle
Mise en œuvre pratique des meilleures pratiques en matière
d’intégration logicielle

Nelson Ruest & Danielle Ruest

Parrainé par Macrovision
Résumé
La majorité des administrateurs système ont découvert que quand ils doivent livrer des logiciels au sein
de leur réseau, ils ont tout intérêt à créer une nouvelle image de l’application spécifique à leur
entreprise (réintégrée) avant de la distribuer. Malheureusement, tout le monde n’utilise pas le même
ensemble de règles pour la réintégration logicielle et évidemment, tout le monde n’obtient pas les
mêmes résultats. Macrovision, le créateur d’AdminStudio (environnement d’intégration intégré complet)
et les auteurs Danielle Ruest et Nelson Ruest, tous deux conseillers en intégration indépendants, ont
défini les 20 commandements de l’intégration logicielle. Il s’agit de conseils pratiques spécifiques
portant sur la meilleure façon d’intégrer des logiciels. Ce livre blanc vous guidera à travers le processus
d’intégration étape par étape et vous donnera des conseils pratiques sur la façon de créer des progiciels
selon les principes définis ici. Vous détiendrez alors un processus complet qui peut vous aider à
assurer la qualité de vos progiciels. Ce livre blanc a pour but de répondre à vos questions et de vous
apprendre à bénéficier de tous les avantages qu’une intégration logicielle bien réalisée peut vous
apporter. Vous pouvez également visionner une diffusion Web couvrant ce sujet afin d’obtenir de plus
amples informations.

A propos des auteurs

Danielle Ruest et Nelson Ruest sont des professionnels de l’informatique spécialisés dans
l’administration des systèmes, la planification des migrations, la gestion des logiciels et la conception
architecturale. Ils sont les auteurs de plusieurs livres, dont deux ouvrages notables publiés par
McGraw-Hill Osborne, « Windows Server 2003: Best Practices for Enterprise Deployments », ISBN 0-07-
222343-X et « Windows Server 2003 Pocket Administrator » , ISBN 0-07-222977-2, ainsi que « Preparing
for .NET Enterprise Technologies », publié par Addison Wesley, ISBN 0-201-73487-7. Ils ont une vaste
expérience de l’intégration logicielle et de la gestion d’importants projets d’intégration.

Les 20 commandements de l’intégration logicielle Page ii

Table des matières
Introduction.................................................................................................. 1
Travailler avec les 20 commandements......................................................... 2
1. Préparez votre environnement d’intégration ..................................... 2
2. Utilisez des flux de travail appropriés .............................................. 4
3. Rassemblez toutes les données du projet avant de commencer........ 7
4. Réalisez des intégrations pour Windows Installer ............................ 8
5. Sachez quand intégrer ..................................................................... 9
6. Réintégrez ou personnalisez toutes vos installations logicielles........ 9
7. Commencez avec un système propre ............................................. 10
8. Exploitez les machines virtuelles.................................................... 11
9. Utilisez le contrôle d’installation pour la réintégration ................... 12
10. Utilisez un modèle d’intégration personnalisé ................................ 13
11. Utilisez une liste d’exclusions globale............................................. 14
12. Connaissez vos progiciels............................................................... 15
13. Utilisez un modèle de construction de systèmes ............................ 17
14. Créez des catalogues de progiciels ................................................. 19
15. Détectez les conflits........................................................................ 21
16. Effectuez les tests en tant qu’utilisateur ........................................ 24
17. Effectuez les tests de déploiement.................................................. 26
18. Documentez vos modifications....................................................... 27
19. Corrigez vos progiciels.................................................................... 27
20. Gérez l’intégration comme un projet .............................................. 30
Conclusion.................................................................................................. 32

Les 20 commandements de l’intégration logicielle Page iii

Introduction
Les administrateurs système intègrent des logiciels depuis les tout
débuts des micro-ordinateurs. En effet, la majorité des administrateurs
système ont découvert qu’ils ont tout intérêt à créer une nouvelle image
de l’application spécifique à leur entreprise (réintégrée) avant de la
distribuer sur leur réseau. Malheureusement, tout le monde n’utilise
pas le même ensemble de règles pour la réintégration logicielle et
évidemment, tout le monde n’obtient pas les mêmes résultats. Une
chose est certaine, si vous gérez vos processus d’intégration logicielle
correctement, vous bénéficierez de frais de propriété totaux inférieurs
pour vos PC. Mais comment garantir un tel résultat ?
Macrovision, le créateur d’AdminStudio (environnement d’intégration
intégré complet) et les auteurs Danielle Ruest et Nelson Ruest, tous
deux conseillers en intégration indépendants, ont défini les 20
commandements de l’intégration logicielle :
1. Préparez votre environnement d’intégration
2. Utilisez des flux de travail appropriés
3. Rassemblez toutes les données du projet avant de commencer
4. Réalisez des intégrations pour Windows Installer
5. Sachez quand intégrer
6. Réintégrez ou personnalisez toutes vos installations logicielles
7. Commencez avec un système propre
8. Exploitez les machines virtuelles
9. Utilisez le contrôle d’installation pour la réintégration
10. Utilisez un modèle d’intégration personnalisé
11. Utilisez une liste d’exclusions globale
12. Connaissez vos progiciels
13. Créez des catalogues de vos progiciels
14. Utilisez un modèle de construction de systèmes
15. Détectez les conflits
16. Effectuez les tests en tant qu’utilisateur
17. Effectuez les tests de déploiement
18. Documentez vos modifications
19. Corrigez vos progiciels
20. Gérez l’intégration comme un projet
En utilisant ces règles, vous apprendrez à exploiter tous les avantages
qu’une intégration logicielle réussie peut vous apporter.

Les 20 commandements de l’intégration logicielle Page 1

Travailler avec les 20 commandements
Chaque commandement traite d’un aspect particulier de l’intégration.
Ensemble, ils couvrent la totalité du processus d’intégration et couvrent
chacune des étapes essentielles de ce processus.

1. Préparez votre environnement d’intégration

Trop peu de personnes prennent le temps de préparer correctement

leur environnement d’intégration. N’oubliez pas qu’un environnement
ou un laboratoire d’intégration logicielle doit être structuré, comme tout
autre environnement de votre réseau. Cela signifie que vous devez
préparer les outils appropriés (des outils tels qu’un référentiel
d’installation pour toutes les installations logicielles sources, un
référentiel logiciel pour toutes les installations intégrées ainsi que des
outils de dépannage appropriés). En outre, vous devez utiliser un
système de base de données approprié pour le stockage de toutes les
informations d’intégration. La plupart des outils d’intégration logicielle
sont fournis avec les bases de données Microsoft SQL Server Desktop
AdminStudio de
Engine (MSDE) ou Microsoft Access Runtime, mais ces outils ont des
Macrovision
limitations qui peuvent avoir un impact négatif sur votre environnement
Essayez une version d’intégration. La limitation la plus importante est la limite de taille de la
d’évaluation entièrement base de données. Si votre base de données dépasse la limite de taille,
fonctionnelle vous risquez de perdre toutes vos données d’intégration. Bien
d’AdminStudio en allant évidemment, c’est une situation à éviter à tout prix. Traitez vos données
à d’intégration comme des données d’entreprise et mettez en œuvre un
www.installshield.com/p système de base de données commercial avec des stratégies de
roducts/adminstudio/ev sauvegarde appropriées.
al.asp
Enfin, utilisez des systèmes représentatifs pour préparer et tester vos
progiciels et mettre en œuvre des mécanismes d’imagerie appropriés
afin de restaurer ces machines à leur état originel.

La figure 1 montre les outils et la structure que vous devriez utiliser

dans votre laboratoire d’intégration. Il s’agit d’un seul laboratoire
d’intégration. Si vous utilisez des équipes d’intégration distribuées, vous
devrez répliquer la même architecture à chaque emplacement et vous
assurer que vos bases de données d’intégration logicielle sont répliquées
à chaque emplacement. Ce laboratoire comprend :
• Microsoft SQL Server 2000 avec Service Pack 3a
• Au moins un serveur jouant plusieurs rôles :
o Stockage des bases de données
o Stockage des fichiers pour toutes les sources d’installations
logicielles
o Stockage des fichiers pour tous les logiciels réintégrés
o Stockage des fichiers pour les images des machines ou les
machines virtuelles

Les 20 commandements de l’intégration logicielle Page 2

 o Référentiel central pour l’environnement d’intégration
intégré, ici AdminStudio® de Macrovision
o Services de répertoire émulant votre réseau de production
o Des postes de travail d’opérateur pour la documentation et
la recherche (ces postes de travail sont connectés à
Internet)Operator workstations aimed at documentation
and research—these workstations are connected to the
Internet

ƒ Des postes de travail, appelés machines

propres, utilisés pour la préparation de
l’intégration
ƒ Des postes de travail de test qui sont
représentatifs des machines de votre réseau de
production
ƒ Une technologie de machine virtuelle
pouvant servir à remplacer les machines
propres physiques
ƒ Des utilitaires d’intégration tels que
SysInternals Regmon, un outil conçu pour
surveiller les modifications du référentiel, et
Filemon, un outil conçu pour surveiller
l’activité des fichiers quand des programmes
sont en cours d’exécution ; ces deux outils
sont gratuits

ƒ Des utilitaires de contrôle de la qualité

d’intégration tels que iTripoli Package
Cleaner, un outil qui vérifie le contenu des
progiciels et joue le rôle de base de
connaissances interne en vous indiquant si
vous devez inclure ou non des composants
spécifiques dans vos progiciels, et pourquoi
ƒ Un outil d’imagerie des machines qui vous
permet de restaurer les machines physiques à
leur état originel à la fin de chaque projet
ƒ Des logiciels de sauvegarde et une
magnétothèque pour protéger vos données
d’intégration

Les 20 commandements de l’intégration logicielle Page 3

 Figure 1. L’environnement d’intégration
Comme vous pouvez le voir, la préparation à l’intégration n’est pas une
mince affaire. Assurez-vous de mettre en œuvre une solution évolutive
et personnalisable. Vous effectuerez des intégrations dans le temps,
assurez-vous donc de la stabilité et de la fiabilité de votre
environnement d’intégration.

2. Utilisez des flux de travail appropriés

Il est essentiel que la personne appropriée fasse le travail approprié au
cours du processus d’intégration et de test. Même si votre équipe
d’intégration ne compte qu’un seul membre, vous devez vous assurer
que vous utilisez un processus d’intégration étape par étape et que vous
le suivez à la lettre.

Si votre équipe compte plus d’un membre, c’est encore mieux, mais
vous devez alors désigner un coordinateur de laboratoire qui sera
chargé de superviser toutes les activités de préparation. De plus, vous
devez vous assurer que vos testeurs sont despersonnes différentes de
vos intégrateurs. Cela contribue à l’amélioration des processus de test.
Rien ne vaut un deuxième regard pour repérer des omissions et des
éléments inattendus.
Le meilleur moyen de vous assurer que les personnes appropriées sont
chargées des tâches appropriées est de vous pencher sur le processus
d’intégration lui-même. Dans le processus d’intégration (figure 2), tout
commence par une demande pour un produit nouveau ou mis à niveau.
Cette demande arrive au laboratoire d’intégration où elle est traitée par
le coordinateur d’intégration et le chef de projet. Le premier affecte des
ressources au projet et le deuxième gère les activités du projet. Le
progiciel est affecté à un membre de l’équipe qui peut même être un
intégrateur subalterne puisque ce processus est relativement simple et
répétitif. L’intégrateur commence par découvrir les fonctionnalités du
progiciel. Ensuite, il doit préparer le progiciel. Une fois le progiciel initial
prêt, il est temps de passer aux tests et à la détection des conflits
potentiels. Si votre équipe est suffisamment importante, vous devriez
penser à séparer le poste de tests et de détection de conflits de

Les 20 commandements de l’intégration logicielle Page 4

 l’intégration, en attribuant ce rôle à un membre ayant plus d’expérience
car les tests sont plus complexes et nécessitent des connaissances plus
approfondies. Il en est de même pour l’assurance qualité (AQ). Comme il
s’agit d’une étape clé du processus, l’affectation de ce rôle à une autre
personne génère de meilleurs résultats. En fait, ce rôle est souvent
mieux rempli par des utilisateurs expérimentés qui connaissent bien le
produit logiciel. Rien ne vaut un deuxième regard expérimenté pour
l’assurance qualité. Le laboratoire distribue alors le progiciel. C’est
généralement le chef de projet qui s’en charge. La distribution est
transférée à l’équipe de déploiement et une fois déployé, le progiciel
passe sous la responsabilité de l’équipe de maintenance jusqu’à sa mise
hors service. Cette mise hors service peut également provoquer une
nouvelle demande de la part des utilisateurs. Ainsi, le processus
d’intégration revient à son point de départ.

Figure 2. Le processus d’intégration

Cela signifie que votre équipe d’intégration devrait inclure les rôles
suivants :
• Coordinateur de laboratoire
• Chef de projet
• Expert en intégration
• Intégrateur
• Testeur et spécialiste de la détection des conflits
• Spécialiste en assurance qualité ou utilisateurs expérimentés
• Spécialiste en déploiement
Ce dernier ne doit pas nécessairement faire partie de l’équipe
d’intégration, mais doit avoir une relation étroite avec cette équipe. Bien
sûr, selon la taille de votre équipe et le nombre de progiciels à gérer,
vous devrez peut-être ajouter des rôles d’administration et de recherche
par exemple. N’oubliez pas de consigner et de publier ce flux de travail
et de le communiquer à tous les membres de l’équipe.

Les 20 commandements de l’intégration logicielle Page 5

 Au sein d’AdminStudio, il est possible d’indiquer les étapes d’intégration
afin d’établir des normes (figure 3).

Figure 3. AdminStudio vous permet d’utiliser le processus

d’intégration quand vous préparez des progiciels
Pour les projets plus importants, un système de flux de travail basé sur
le Web et centralisé comme AMS de Macrovision peut être ajouté à la
fonctionnalité AdminStudio afin d’accroître le niveau de coordination
(figure 4).

Les 20 commandements de l’intégration logicielle Page 6

 Figure 4. AMS de Macrovision vous permet de contrôler le
processus de demande et le flux de travail d’intégration tout en
envoyant des rapports d’état aux utilisateurs

3. Rassemblez toutes les données du projet avant de

commencer
Maintenant que vous êtes prêt à préparer des progiciels, vérifiez que
vous détenez bien toutes les informations portant sur le progiciel avant
de commencer. Cela inclut les instructions d’installation élémentaires,
le fabricant, les numéros de téléphone d’assistance du fabricant, les
machines sur lesquelles le progiciel sera déployé, les éléments à inclure
ou exclure du progiciel et, bien sûr, les normes de votre entreprise
portant sur l’intégration et la préparation de l’intégration.
Vous pouvez facilement trouver bon nombre de ces informations sur les
sites Web des fabricants. D’autres seront incluses sur le formulaire de
demande de progiciel que vous créez ou proviendront d’utilisateurs
expérimentés qui savent ce que peut faire le produit logiciel en
question. Savoir quelles machines sont concernées vous sera utile dans
les étapes d’intégration ultérieures car vous aurez ainsi des
informations sur les produits avec lesquels le progiciel devra cohabiter.
Enfin, les normes de votre entreprise pour l’intégration devraient être
bien documentées et devraient être intégrées à une formation
élémentaire pour tout nouveau stagiaire en intégration.
Une bonne source d’informations sur les progiciels plus ou moins
génériques est le site Web Appdeploy.com. Ce site comprend de très
nombreuses informations sur l’intégration, mais sa section la plus utile
est probablement la base de connaissances en intégration (packaging
knowledge base). A ce jour, cette base de connaissances comprend des
informations pour plus de 350 produits.

Les 20 commandements de l’intégration logicielle Page 7

 Armé des bonnes informations, vous parviendrez à créer votre progiciel
du premier coup.
En utilisant AMS, les demandeurs d’applications d’une entreprise
peuvent envoyer des informations par le biais d’une interface Web
centralisée. Cette interface peut inclure les champs obligatoires mais
aussi des champs facultatifs. Il est également possible d’envoyer des
fichiers connexes, tels quedes contrats de licence, des modèles et des
instructions (figure 5).

Figure 5. Préparation d’une demande de progiciel dans AMS

4. Réalisez des intégrations pour Windows Installer

Nous avons de la chance. Aujourd’hui, nous disposons d’un système
d’installation standard pouvant être utilisé pour l’installation de tous
les progiciels et logiciels sur vos systèmes Windows. Cette norme, le
format Windows Installer (aussi connu sous le nom de MSI), fournit des
fonctionnalités de gestion des installations avancées.
L’un des gros avantages de ce système est que bien que tous les
fournisseurs n’utilisent pas encore tous ce format pour leurs propres
installations, beaucoup le font et beaucoup d’autres s’orientent dans
cette direction chaque jour. Un autre avantage est que même si un
progiciel n’adhère pas à cette norme, il est relativement simple de
convertir des installations à ce format en utilisant des outils tels
qu’AdminStudio. Enfin, l’utilisation de cette norme signifie que votre
personnel n’a à connaître qu’un seul format d’installation.
Les progiciels Windows Installer ou MSI fournissent une vaste gamme
de fonctionnalités : restauration automatique, normalisation des règles
de versions des fichiers, approches de personnalisation standard des
installations, promotion par le biais d’Active Directory et bien plus

Les 20 commandements de l’intégration logicielle Page 8

 encore. En outre, si vous exécutez Service Pack 2 pour Windows XP,
vous avez accès à la version 3.0 du service Windows Installer. La
version 3.0 traite les correctifs et la prise en charge des correctifs pour
les logiciels installés. Un avantage conséquent est que vous n’avez plus
besoin d’avoir accès aux installations sources pour pouvoir appliquer
des correctifs aux applications, puisque Windows Installer utilise
désormais la base de données d’installation locale pour le processus de
correction.

Sans tarder, vous découvrirez que l’utilisation de progiciels MSI apporte

un large éventail d’avantages pour les installations. Comme tous vos
logiciels seront capables de restauration automatique, vous devriez voir
diminuer le nombre d’appels au service d’assistance dus à des logiciels
ne fonctionnant pas après le déploiement. En outre, vous travaillerez
avecun seul mécanisme d’installation intégré, ce qui simplifie
considérablement le processus d’intégration global.

5. Sachez quand intégrer

Il existe de nombreux éléments que vous ne devriez pas intégrer :
gestionnaires, composants système, installations Internet Explorer,
réparations à chaud, service packs, etc. En effet, il s’agit de composants
du système d’exploitation principaux ou de composants qui utilisent un
format déjà intégré.
Par exemple, les installations de gestionnaires effectuent des
modifications à un niveau bas du système d’exploitation et ne doivent
donc pas être réintégrées au format MSI. Internet Explorer utilise
également son propre moteur pour les installations et la
personnalisation ; il ne doit donc pas être réintégré au format MSI. Les
réparations à chaud et les service packs ont également leur propre
format d’installation. Certains seront déjà sous la forme d’un correctif
Windows Installer ou MSP et doivent être appliqués à un MSI existant
pour fonctionner. Ils ne doivent jamais être réintégrés dans un MSI car
vous perdriez l’accès aux fonctionnalités MSI d’origine.
Cela ne signifie pas que vous ne pouvez pas inclure une installation de
gestionnaire dans un MSI dans le cadre d’une installation complexe,
mais simplement que si vous le faites, vous devez utiliser une solution
scriptée qui s’installera avec le MSI mais qui n’utilisera pas le processus
MSI pour prendre en charge l’installation.
Documentez et publiez toutes les exclusions qui s’appliquent à votre
processus d’intégration.

6. Réintégrez ou personnalisez toutes vos installations

logicielles
Ne vous fiez pas aux installations des fournisseurs car les paramètres
par défaut peuvent ne pas s’appliquer aux normes que vous appliquez
dans votre réseau. Assurez-vous de personnaliser tous vos progiciels.
Pour ce faire, utilisez le processus approprié. Si le progiciel est déjà au
format Windows Installer, vous devez le personnaliser, mais seulement
par le biais de transformations (MST) qui sont appliquées à l’installation
commerciale d’origine. S’il n’est pas au format Windows Installer,
utilisez un processus de capture pour le réintégrer dans ce format.

Les 20 commandements de l’intégration logicielle Page 9

 Les progiciels peuvent être divisés en trois catégories :
• Logiciels Windows Installer natifs — Ces logiciels incluent tout
produit incluant un MSI original ou satisfaisant à la spécification
Designed for Windows. L’une des spécifications de ce programme
est l’intégration au service Windows Installer. L’installation de ces
produits doit être transformée en configurations personnalisées
pour votre réseau. En effet, il est fortement conseillé de conserver
les installations MSI d’origine telles quelles et d’appliquer les
modifications et la personnalisation nécessaires par le biais d’un
fichier MST, qui applique vos propres paramètres à l’installation par
défaut au cours de déploiement.
• Applications d’entreprises intégrées MSI — Les versions
nouvelles ou mises à niveau des applications d’entreprise doivent
être intégrées et conçues pour fonctionner avec le service Windows
Installer. Vos développeurs internes doivent apprendre à travailler
dans ce format. Remarque : Il est possible que ces MSI ne
nécessitent pas de personnalisation puisqu’ils sont conçus pour
votre environnement et que l’installation d’origine inclut donc peut-
être tous les paramètres personnalisés.

AdminStudio Editor de • Applications d’entreprise et logiciels commerciaux réintégrés —

Macrovision permet de Tous les produits logiciels commerciaux qui ne sont pas ou ne
travailler avec des peuvent pas être mis à niveau doivent être réintégrés afin
fichiers MSI natifs, ainsi d’incorporer leur installation à Windows Installer. Environ 99 % de
que de modifier et de ces anciens produits logiciels devraient pouvoir être réintégrés afin
créer des MST. de profiter de Windows Installer. Seuls les produits tels que les
gestionnaires de périphériques, les programmes qui installent les
gestionnaires de périphériques ou les programmes qui effectuent
des modifications de niveau bas du système d’exploitation ne
pourront pas être incorporés à Windows Installer. En outre, les
applications d’entreprise ne nécessitant pas de reprogrammation,
n’étant pas mises à niveau ou ne pouvant pas être reprogrammées
doivent également être réintégrées au format Windows Installer.
Dans ces cas, vous n’aurez pas besoin de transformations car vous
utiliserez un processus de capture d’installation afin de convertir
l’ancienne installation en déploiement configuré utilisant un seul
MSI.
Un autre facteur clé est le fait que les progiciels ne sont plus
uniquement destinés aux PC ; vous pouvez et devez appliquer aux
serveurs les mêmes principes d’intégration logicielle que vous utilisez
pour les PC.

Assurez-vous que votre équipe d’intégration adhère à ces normes.

7. Commencez avec un système propre

La dernière chose à faire est d’intégrer n’importe quoi. La seule façon de

garantir que vos progiciels n’incluent que le contenu requis est d’utiliser
des systèmes propres pour les préparer et les tester. Les systèmes propres
donnent les meilleurs résultats car ils ne capturent que ce qui est pertinent et
n’incluent aucun composant importuns.

Les 20 commandements de l’intégration logicielle Page 10

 En fait, votre laboratoire devrait inclure une copie de chaque machine
cible dans le réseau. Il devrait également inclure une technologie
d’imagerie de disque pour accélérer le processus de restauration des
systèmes cibles à leur état originel pour chaque test.

Les systèmes propres donnent les meilleurs résultats car ils ne capturent que
ce qui est pertinent. Les systèmes propres doivent être utilisés de la
façon suivante :

L’outil AdminStudio • Création du progiciel — Les machines d’origine utilisées pour

Repackager peut être
installé séparément et
mieux encore, peut
s’exécuter à distance.
Cela signifie que
l’intégrateur peut
mapper un disque du
système propre sur
l’emplacement de
réseau avec
l’exemplaire de
Repackager et le lancer
à partir de cet
emplacement. Ainsi,
aucune partie
d’AdminStudio n’est
installée sur le système
de construction du
progiciel, qui reste donc
aussi propre que
possible.
créer les progiciels doivent être aussi propres que possible. Cela
signifie souvent que tout ce dont vous avez besoin sur ces
machines est le système d’exploitation, les correctifs du système
d’exploitation appropriés et les composants requis de l’outil
d’intégration que vous utilisez. Ces machines doivent être le
plus puissantes possible pour accélérer la création des
progiciels. Une fois une machine préparée, elle doit être imagée
afin de conserver son état originel. Puis, après la création et
l’enregistrement de chaque progiciel, la machine doit être ré-
imagée pour restaurer son état originel.
• Tests du progiciel — Les machines cibles pour les tests du
progiciel doivent être aussi similaires que possible aux machines
véritables sur lesquelles sera exécuté le progiciel sur le réseau.
Cela signifie qu’il faut inclure le système d’exploitation, tous les
logiciels génériques principaux et tout logiciel particulier
résidant sur les systèmes cibles. Une fois une machine
préparée, elle doit être imagée afin de conserver son état
originel. Il faut rétablir cet état originel à la fin de chaque série
de tests sur un progiciel.

Cela signifie que vous aurez besoin de beaucoup d’espace disque sur le
serveur de votre laboratoire d’intégration pour stocker ces images
matérielles, ainsi que d’un réseau haut débit pour charger et télécharger
ces images pendant l’intégration.

8. Exploitez les machines virtuelles

Les technologies de machines virtuelles, telles que Microsoft Virtual PC
2004 et Virtual Server 2005 ou VMware Workstation 4.5 et GSX Server
3.1, devraient faire partie de toute boîte à outils d’intégration. Les
machines virtuelles émulent les serveurs et PC standard quasi
parfaitement et il est beaucoup plus facile de restaurer leur état
originel. Elles sont même capables d’annuler les modifications
apportées à leurs disques durs, ce qui rend la restauration de leur état
originel extrêmement simple.
Idéalement, les machines virtuelles devraient être utilisées à la place
des machines de création de progiciels d’origine. En effet, ce sont des
machines génériques, qui émulent le type de machine le plus
élémentaire et prennent entièrement en charge le processus de création
de progiciels. En outre, elles peuvent être utilisées pour effectuer les
tests de progiciels initiaux. Par contre, pour entièrement tester le
fonctionnement des progiciels sur votre réseau, vous devez utiliser de
véritables machines de tests d’intégration.

Les 20 commandements de l’intégration logicielle Page 11

 Vous pouvez utiliser les machines virtuelles de deux façons différentes.
La première vous permet d’utiliser la capacité d’annulation proposée
par chaque fournisseur pour simplement n’enregistrer aucune des
modifications que vous pouvez avoir appliquées à un fichier de disque
dur d’une machine virtuelle. C’est très simple et cela vous permet de
créer un progiciel, de l’enregistrer, puis de simplement fermer la
machine et ainsi de supprimer toute modification apportée au disque.
La deuxième s’appuie sur la nature même des machines virtuelles. En
réalité, les machines virtuelles ne sont que des fichiers sur votre disque
dur. Cela signifie qu’avant d’effectuer un test, vous pouvez copier ces
fichiers dans un nouveau dossier afin de sauvegarder une copie de
l’état originel de la machine. Il vous suffit ensuite de préparer le
progiciel, de l’enregistrer et de simplement supprimer les fichiers
composant la machine que vous venez d’utiliser. Copiez à nouveau les
fichiers d’origine pour créer un autre progiciel. C’est souvent la façon la
plus simple d’utiliser les machines virtuelles.
Mais comme vous pouvez le voir, les machines virtuelles nécessitent
beaucoup d’espace disque puisque chaque machine virtuelle peut faire
4 Go en moyenne. Elles doivent être stockées sur le serveur. Un réseau
haut débit est nécessaire pour aider à accélérer le processus de copie
des machines. En outre, les machines physiques utilisées pour exécuter
ces machines virtuelles pour l’intégration doivent disposer
d’importantes quantités de RAM (au moins 1 Go) et d’espace disque.
AdminStudio inclut également des « crochets » spéciaux qui vous
permettent d’exploiter les machines virtuelles directement par le biais
de l’environnement d’intégration intégré.

9. Utilisez le contrôle d’installation pour la réintégration

Il existe plusieurs façons de réintégrer des produits. L’une des plus

prisées est l’approche par instantanés. En gros, cette technique dresse
l’inventaire de ce qui se trouve sur le système avant et après
l’installation, capturant les modifications du système effectuées par
l’installation en identifiant les différences.

Une deuxième approche, beaucoup plus puissante, est le contrôle de

l’installation. Il s’agit d’une technique rapide et précise qui contrôle ce que
fait le système au cours de l’installation. Ainsi, elle est plus efficace et
assure de meilleurs résultats que la méthode par instantanés avant et
après l’installation.

Dans AdminStudio, vous pouvez choisir la méthode que vous désirez

utiliser dans l’un des premiers panneaux de l’assistant Repackaging Wizard
(assistant de réintégration) (figure 6).

Les 20 commandements de l’intégration logicielle Page 12

 Figure 6. Choix de la méthode de réintégration dans AdminStudio

10. Utilisez un modèle d’intégration personnalisé

En travaillant avec les progiciels, vous vous rendrez compte qu’ils

tombent dans une série de catégories. Chacune de ces catégories
incluent des tâches répétitives et nécessitent l’application des
normes d’intégration de l’entreprise. La meilleure façon de s’assurer
que ces normes sont toujours appliquées est de les capturer dans
un modèle d’intégration, un modèle qui est appliqué au progiciel au
tout début de sa création. Les modèles sont des outils puissants car
ils vous permettent de capturer et d’y inclure des connaissances
d’intégration sophistiquées, ce qui facilite le processus d’intégration
initial pour les intégrateurs subalternes et libère les intégrateurs
experts pour leur permette de se consacrer à des tâches
d’intégration plus complexes.

Pour utiliser un modèle d’application lors de la réintégration

d’applications dans AdminStudio :
1. Lancez AdminStudio Editor et créez un projet incluant les
propriétés, boîtes de dialogue, fonctionnalités et composants par
défaut de votre choix.
2. Enregistrez le projet en tant que modèle InstallShield (modèle
InstallShield) (*.ist).
3. Utilisez le Repackager pour capturer les informations portant
sur une application et à l’étape de création, pointez vers le
modèle préalablement créé (figure 7).

Les 20 commandements de l’intégration logicielle Page 13

 Figure 7. Utilisation d’un modèle personnalisé dans
AdminStudio

11. Utilisez une liste d’exclusions globale

De nombreux composants ne devraient jamais être inclus à un
progiciel : fichiers temporaires, fichiers système, fichiers INI, clés de
registre, etc. Ces composants doivent être inclus à une liste
d’exclusions qui sera appliquée à tous les progiciels lors de leur
création. Si vous utilisez une liste d’exclusions globale appropriée et
complète, elle vous permettra de gagner beaucoup du temps que vous
devez consacrer à la suppression des données non désirées et inutiles
des progiciels que vous créez.
Pour utiliser une liste d’exclusion d’intégration lors de l’intégration
d’applications avec AdminStudio :

1. Lancez le Repackager.
2. Sélectionnez Tools | Global Exclusions Editor (Outils |
Editeur d’exclusions global) et modifiez la liste des fichiers et
des entrées de registre à exclure pendant le processus de
capture (figure 8).

Les 20 commandements de l’intégration logicielle Page 14

 Figure 8. Ajout d’exclusions par le biais de l’éditeur d’exclusions global

Bien que les exclusions qui font déjà partie d’AdminStudio soient
complètes, il y a toujours des particularités qui ont un lien direct avec la
façon dont votre environnement de réseau, vos postes de travail et vos
progiciels sont configurés qui doivent être prises en considération.

L’un des meilleurs outils que vous pouvez utiliser pour la prise en
charge de vos listes d’exclusion est iTripoli Package Cleaner (voir le
commandement 1 ci-dessus). Package Cleaner est un produit conçu
pour examiner le contenu des progiciels et identifier clairement les
composants et paramètres devant être inclus ou non dans un progiciel.
Le plus gros avantage de Package Cleaner est qu’il souligne pourquoi
vous ne devriez pas inclure ces composants dans votre progiciel. Avec
Package Cleaner, vous avez un véritable expert de l’intégration à votre
disposition. De plus, toute exclusion que Package Cleaner identifie peut
être ajoutée aux exclusions avec lesquelles vous travaillez dans
AdminStudio, améliorant encore davantage vos futurs progiciels.

12. Connaissez vos progiciels

Lors de la préparation d’un progiciel, vous devez extraire le maximum
d’informations du progiciel. Les environnements d’intégration intégrés
incluent des outils spéciaux conçus pour vous aider à obtenir beaucoup
plus d’informations d’un progiciel pendant sa préparation. Par exemple,
AdminStudio inclut deux outils qui peuvent vous être utiles dans cette
situation. SmartScan est un outil qui identifie automatiquement tout
fichier requis pour que le progiciel fonctionne mais qui est absent du
progiciel. SmartScan ajoute ces fichiers dans un format à code couleur
pour que vous sachiez ce qui est nécessaire au fonctionnement correct
du progiciel. L’assistant Setup Intent Wizard (assistant d’intention
d’installation) vous aide également à identifier les fichiers ayant un lien
avec le progiciel et qui en sont absents. Ces deux outils vous permettent
d’obtenir autant d’informations que possible au sujet de votre progiciel.
SmartScan d’AdminStudio devient visible à la fin du processus de
réintégration si des informations supplémentaires peuvent être
rassemblées à partir des fichiers d’installation basés sur InstallScript. A
ce stade, l’intégrateur aura la possibilité d’inclure les fichiers

Les 20 commandements de l’intégration logicielle Page 15

 supplémentaires et les informations de hiérarchie de fonctionnalités
(figure 9).

Figure 9. Utilisation de SmartScan pour obtenir des informations

supplémentaires au sujet du progiciel

Pour travailler avec l’assistant Setup Intent Wizard (assistant

d’intention d’installation), sélectionnez le lien « Scan for setup intent »
(Rechercher l’intention d’installation) dans l’environnement de
développement intégré du Repackager. L’assistant recherche les
dépendances de fichiers supplémentaires qui n’ont peut-être pas été
installées et affiche les résultats (figure 10).

Les 20 commandements de l’intégration logicielle Page 16

 Figure 10. Utilisation de l’assistant Setup Intent Wizard (assistant
d’intention d’installation) pour identifier les dépendances de fichiers
supplémentaires

13. Utilisez un modèle de construction de systèmes

Another key method to help reduce the complexity of creating packages
is to use a system construction model. This means that you build a core
system and add all generic capabilities to this system. This image or
“system stack” is then applied to all PCs or servers. From then on, you
create groups of applications that can be deployed to groups of users
identified through the role they play in your organization.
The system stack basically identifies the components, common and
particular, that you’ll find on different systems in your network. This
means a couple of things. First, you have to find the common elements
to all systems, either servers or PCs, and fit them together. This should
include the operating system, service packs, utilities, office automation
products, graphics file viewers, antivirus, document viewers, and so on.
Once this is done, you can package this common stack into images that
can be deployed as a blob through the network.
AdminStudio supports the system stack concept through the capture of
Operating System images:
1. Lancez l’assistant OS Snapshot Wizard (assistant d’instantanés du
système d’exploitation) et nommez l’image à capturer (figure 12).
Figure 1. A System Stack
Example, in this case, the
Accounting Stack

Les 20 commandements de l’intégration logicielle Page 17

 Figure 12. Capture d’un système d’exploitation
2. Les données du système sont capturées et enregistrées (figure 13).
L’assistant OS Snapshot Wizard (assistant d’instantanés du
système d’exploitation) peut être exécuté à distance, ainsi aucune
partie d’AdminStudio n’est nécessaire sur le système de référence
propre en train d’être capturé. Une fois enregistrées, elles peuvent
être importées dans le catalogue d’applications.

Les 20 commandements de l’intégration logicielle Page 18


AdminStudio lets you group
packages according to audience
when detecting and repairing
conflicts.
Les 20 commandements de l’intégration logicielle
Figure 13. Capture d’un système d’exploitation en cours
Une fois la pile système en place, vous devez apprendre à la gérer et la
maintenir comme un objet unique. Dans la vie réelle, trois mises à jour
complètes chaque année suffisent. Bien sûr, vous devez aussi prévoir les
déploiements de mises à jour d’urgence. N’oubliez pas que chaque fois que
vous modifiez la pile système, vous devez la recapturer avec AdminStudio.
14. Créez des catalogues de progiciels
Une fois que vous utilisez le concept de pile système, vous devez
également identifier des regroupements spéciaux ou catalogues de
progiciels ciblant des groupes d’exploitation spécifiques au sein de votre
réseau. Par exemple, les comptables peuvent avoir besoin d’un jeu
d’outils donné en plus du jeu commun, alors que le personnel de vente
peut avoir besoin d’un autre jeu d’outils différent. Au sein du service de
comptabilité, il est possible que certains employé se concentrent sur les
rapports et d’autres sur le regroupement de données et ces utilisateurs
ont besoin d’outils supplémentaires en plus de la pile de comptabilité.
La figure 11 ci-dessus illustre l’approche de pile système complète.
Si vous appliquez cette stratégie, vous vous rendrez vite compte que
créer des progiciels en s’appuyant sur une telle stratégie réduit
considérablement les efforts d’intégration car elle réduit le nombre de
programmes devant cohabiter sur un système donné. En effet, une
grande partie des système n’ont besoin que de la pile commune. Ces
systèmes sont donc les plus faciles à gérer. En outre, en combinant
d’autres programmes dans des groupes, vous devriez pouvoir réduire la
Page 19
 complexité de chaque système. Ces groupes comprennent rarement
plus de 5 à 30 programmes individuels selon le public ciblé.
Il est très probable que vous vous retrouviez avec certains programmes
pour lesquels le public ciblé est très limité ou qui ont des publics qui ne
peuvent pas être regroupés. Ces programmes ne s’adaptent
correctement dans aucune pile, mais ils devraient
être peu nombreux et ne devraient pas représenter plus de 5 % des
logiciels de vos réseaux. Ils doivent malgré tout être intégrés
correctement afin de permettre une distribution centralisée et une
installation automatisée, ainsi qu’une documentation appropriée.
L’utilisation d’une méthode de création de pile système avec des
catalogues d’applications aidera vos efforts d’intégration et de gestion
des logiciels de plusieurs façons. D’abord, cela simplifie la prise en
charge des systèmes car vous savez à quoi vous attendre sur chaque
système. Ensuite, cela simplifie les déploiements sur des nouvelles
machines car la pile commune est capturée dans une image du disque.
De plus, cela simplifie le déploiement logiciel car vous pouvez regrouper
la pile logicielle pour n’importe quel public spécifique et l’envoyer aux
machines ciblées sous la forme d’un seul déploiement. Enfin, cela
simplifie le contrôle de la qualité de vos progiciels car vous n’avez qu’à
tester les progiciels sur la pile dont ils font partie, et non avec tous les
logiciels de votre réseau.
AdminStudio prend ce concept en charge dans le catalogue des
applications. Les applications peuvent être importées dans la base de
données directement dans le groupe désiré ou peuvent être déplacées
d’un groupe à un autre comme dans un système de fichiers (figure 14).

Figure 14. Utilisation du catalogue des applications dans AdminStudio

Les 20 commandements de l’intégration logicielle Page 20

 15. Détectez les conflits
L’une des raisons principales pour intégrer les progiciels au format
MSI est que le service Windows Installer inclut des fonctionnalités
spéciales, permettant de gérer les conflits logiciels « à la volée ».
Cependant, cela n’élimine pas la nécessité de tester tous les
progiciels afin de détecter les conflits potentiels avec tous les autres
logiciels avec lesquels ils cohabiteront sur un système.
Lorsque vous effectuez les tests pour détecter les conflits, vous
devez utiliser les tests de validation internes, vérifier par rapport
aux règles d’évaluation de cohérence interne et aux règles
d’évaluation de cohérence inter-applications. En utilisant
l’environnement d’intégration intégré pourcréer des catalogues
d’applications et regrouper les applications dans ces catalogues
(figure 14), vous réduisez le temps nécessaire à la détection des
conflits.
Un environnement d’intégration intégré bien conçu résout
automatiquement les conflits en utilisant des règles. Il devrait donc
inclure un jeu complet de règles intégrées, mais comme le but de
l’intégration logicielle est de configurer les logiciels selon des normes
d’entreprise qui peuvent être identiques ou non aux normes
d’autrui, il doit également prendre en charge la création de règles
personnalisées. Ainsi, vous pouvez contrôler toutes les
idiosyncrasies du processus d’intégration.
La détection des conflits doit couvrir tous les aspects du progiciel et
doit comparer tous les éléments qui le composent. Cela inclut :

• Composants du produit — Chaque composant du produit est

conçu pour prendre en charge les fonctionnalités individuelles
du produit.
• Fichiers du produit — Les fichiers individuels qui composent
le produit ; dans de nombreux cas, cela met l’accent sur les
bibliothèques de liens dynamiques (DLL) et les fichiers
exécutables (EXE).
• Entrées du registre — Les paramètres du registre qui
prennent en charge l’exploitation du produit.
• Raccourcis et fichiers INI — Les outils permettant d’accéder
au produit une fois qu’il est installé et les paramètres qui sont
appliqués au lancement du produit, bien que la plupart des
produits Windows Installer n’utilisent généralement pas de
fichiers d’initialisation.
• Ressources ODBC (interface universelle de connexion aux
bases de données) — Les composants qui connectent le
produit à des bases de données principales si nécessaire.
• Services NT — Les services intégrés conçus pour
fonctionner en arrière-plan ; ils s’appliquent
essentiellement aux applications de serveur bien que « NT »
soit un nom dépassé.
• Extensions de fichiers — Les éléments qui relient les fichiers
créés par le produit au produit même ; par exemple, les

Les 20 commandements de l’intégration logicielle Page 21

 premières versions de Microsoft Systems Management Server
utilisaient l’extension PDF pour les fichiers de définition de
progiciels, alors qu’Adobe Acrobat utilisaient la même extension
pour son format de document portable.

• Propriétés du produit — Les paramètres qui identifient le

produit sur la machine sur laquelle il est installé.

Bien que certains de ces éléments puissent causer des irritations mineures
(raccourcis, fichiers INI et propriétés), d’autres peuvent provoquer des
conflits importants et même endommager les produits existants sur les
systèmes cibles. C’est pour cette raison qu’il est essentiel de détecter les
conflits et d’y remédier. La figure 15 illustre le processus de détection de
conflits.

Figure 15. Détection des conflits par rapport à une pile système

En testant les progiciels par rapport aux groupes de produits qui

devraient cohabiter sur un système cible, et seulement à ces produits,
vous pouvez améliorer la qualité de vos progiciels sans trop accroître la
charge de travail d’intégration. Cela réduit considérablement l’impact de
la détection et de la résolution de conflits sur le processus d’intégration
car il n’est pas nécessaire de vérifier ou de tester la cohabitation de
programmes contenus dans différents groupes puisqu’il est peu
probable qu’ils n’aient jamais à cohabiter sur le même système. Par
exemple, un utilitaire de génération de rapports de comptabilité doit
être testé par rapport à la pile de comptabilité, mais il n’y aucune raison

Les 20 commandements de l’intégration logicielle Page 22

 de le tester par rapport à la pile d’administration informatique puisqu’il
ne devrait jamais y avoir de raisons de l’installer dans cette pile.
Pour détecter les conflits dans AdminStudio, vous devez utiliser
l’assistant Conflict Wizard (assistant de conflits).
1) Il est possible de lancer l’assistant Conflict Wizard pour toute
application à l’intérieur ou à l’extérieur du catalogue des
applications.

2) Il vous permet de sélectionner des groupes ou des applications

individuelles dans la pile système par rapport auxquels vous voulez
effectuer les tests (figure 16).

Figure 16. Identification des progiciels par rapport auxquels

détecter des conflits dans AdminStudio

1. Il vous suffit ensuite de sélectionner les tests spécifiques que vous

voulez exécuter par rapport aux éléments de la pile système choisis.

Les 20 commandements de l’intégration logicielle Page 23

 Figure 17. Identification des tests à exécuter
Les résultats des tests de détection de conflits sont conservés dans le
catalogue des applications pour cette application et peuvent être utilisés
pour d’autres tests d’applications au fur et à mesure que le nombre de
progiciels que vous préparez augmente.

16. Effectuez les tests en tant qu’utilisateur

Trop d’administrateurs oublient ce qu’ils sont : des administrateurs
disposant des droits d’accès complets à une machine lorsqu’ils
préparent un progiciel. A cause de cela, beaucoup de problèmes
peuvent survenir une fois que le progiciel est entre les mains de
l’utilisateur. Travaillez toujours avec deux comptes, l’un avec des
droits administratifs et l’autre avec des droits d’utilisateur normaux.
Puis utilisez la commande Exécuter en tant que de Windows pour
tester l’application et la capacité de l’environnement d’intégration
intégré à tester les comportements dans un environnement
verrouillé avant de déployer le progiciel à des utilisateurs disposant
de droits limités.
En outre, l’outil QualityMonitor (Contrôleur de qualité)
d’AdminStudio fournit cette fonctionnalité.
1) Lancez QualityMonitor et sélectionnez une application à tester
dans la liste des progiciels MSI installés.
2) Choisissez l’option Lockdown and Runtime Tests (Tests de
verrouillage et d’exécution), choisissez un fichier EXE à tester,
puis cliquez sur Exécuter en tant que ou Run As (figure 18).

Les 20 commandements de l’intégration logicielle Page 24

 Figure 18. Utilisation de QualityMonitor pour effectuer les tests en
tant qu’utilisateur

1. Entrez les informations de connexion vous permettant

d’effectuer les tests en tant qu’utilisateur normal, plutôt qu’en
tant qu’administrateur (figure 19).

Cela vous permet de vous assurer que l’application fonctionnera

correctement lorsqu’elle est utilisée par des gens ne disposant que des
droits et permissions d’utilisateur normal.

Figure 19. QualityMonitor exploite la fonction générique Exécuter

en tant que de Windows pour effectuer les tests

Les 20 commandements de l’intégration logicielle Page 25

 17. Effectuez les tests de déploiement
L’installation d’un progiciel dans un environnement de laboratoire
(l’environnement dans lequel vous préparez le progiciel) signifie souvent
obtenir le progiciel à partir d’un partage de réseau. Cependant, quand
un progiciel est livré aux utilisateurs, il est généralement déployé par le
biais d’un système de livraison logicielle distant. Beaucoup de
problèmes peuvent survenir si ce déploiement n’est pas testé avant la
distribution réelle du logiciel. Les progiciels déployés sont souvent
installés en arrière-plan par le biais d’une installation silencieuse. De
plus, les progiciels déployés nécessitent que des conditions spécifiques
soient satisfaites sur les systèmes cibles pour que le déploiement
fonctionne correctement. Avec un environnement d’intégration intégré
comme AdminStudio, vous pouvez créer des progiciels instrumentés
(des progiciels qui incluent tous les comportements d’une installation
mais qui ne modifient pas les systèmes cibles) et les tester avec de
petits échantillons de groupes cibles. Ainsi, vous saurez si les
ordinateurs cibles sont prêts pour le progiciel ou non et vous accroîtrez
le taux de succès de vos déploiements.
Dans AdminStudio, le test de prédéploiement crée des progiciels de test
qui exécuteront des tests sur le système cible, mais qui n’installeront
rien.
1) Une fois un progiciel sélectionné, un certain nombre de tests
peuvent être inclus. C’est à vous de choisir les tests que vous voulez
inclure (figure 20).

Figure 20. Sélection des tests à exécuter dans le test de

prédéploiement
2) Le progiciel instrumenté peut être déployé sur n’importe quel
nombre de systèmes d’utilisateurs finaux « live » ; les résultats des

Les 20 commandements de l’intégration logicielle Page 26

 tests sont envoyés à un emplacement central et peuvent être
consultés par le biais d’une interface Web (figure 21).

Figure 21. Consultation des résultats du test de prédéploiement

18. Documentez vos modifications

Il est essentiel de documenter la façon dont les progiciels sont faits, mais
comme vous le savez, la documentation est rarement le point fort de vos
techniciens. Néanmoins, vous devez documenter les modifications
apportées aux progiciels lors de leur préparation, sinon vos intégrateurs
risquent de répéter les mêmes tâches ou pire, d’effectuer des tâches
conflictuelles quand ils préparent les progiciels. Si votre équipe a horreur
d’écrire, utilisez les capacités de l’environnement d’intégration intégré pour
capturer toutes les opérations d’intégration et toutes les données de tests.
Cela réduit considérablement le volume de documentation que vos
techniciens doivent rédiger.

Une fois tous les tests et la détection de conflits terminés, vous devez
effectuer une dernière tâche d’assurance qualité pour le progiciel.
Idéalement, la personne qui effectue cette dernière tâche d’assurance
qualité n’est pas la même que celle qui a initialement intégré le produit.
Cela vous assure une vérification meilleure et plus approfondie. A ce stade,
n’oubliez pas de terminer toute la documentation portant sur ce progiciel.
Trop d’entreprises essaient de gagner du temps en attendant que le produit
soit déployé pour s’occuper de la documentation et souvent elles se rendent
compte qu’un composant clé a été oublié et elles n’ont aucun moyen de
savoir comment le réparer.

19. Corrigez vos progiciels

Aujourd’hui, les correctifs sont monnaie courante. Peu de produits
logiciels ne nécessitent jamais de correctifs Assurez-vous d’identifier
tout correctif nécessaire pour les progiciels que vous préparez et si
possible, assurez-vous qu’ils sont appliqués avant le déploiement du
progiciel. Vous vous rendrez compte qu’il est beaucoup plus facile
d’appliquer un correctif dans le laboratoire d’intégration plutôt qu’une
fois le progiciel déployé.
Utilisez votre environnement d’intégration intégré pour vous aider à
déterminer l’impact des correctifs avant leur application. Incluez les
correctifs que vous avez l’intention de déployer à l’intérieur de vos
catalogues d’applications. Cela vous permet d’identifier rapidement les

Les 20 commandements de l’intégration logicielle Page 27

 applications risquant d’être affectées par le correctif et de
considérablement réduire le temps nécessaire aux tests d’un correctif
avant le déploiement.
AdminStudio fonctionne avec Patch Impact Manager de Macrovision, un
outil qui vous permet d’identifier les correctifs disponibles et de les
tester pour les produits que vous avez intégrés. Pour ce faire, suivez le
processus suivant :
1. Rassemblez toutes les dernières données de correctifs Microsoft
en utilisant la fonctionnalité de récupération de correctif.
2. Importez les correctifs qui vous intéressent dans le catalogue
des applications (figure 22).

Figure 22. Importation de correctifs choisis dans le catalogue des

applications d’AdminStudio
3. Sélectionnez un ou plusieurs correctifs, exécutez l’assistant
Patch Analysis Wizard (assistant d’analyse de correctifs), puis
sélectionnez les instantanés de système d’exploitation et
applications à utiliser pour l’analyse (figures 23 et 24).

Les 20 commandements de l’intégration logicielle Page 28

 Figure 23. Sélection des correctifs à tester
4. Le contenu des correctifs est comparé au contenu des
instantanés de système d’exploitation et applications choisis,
ainsi qu’aux dépendances de fichiers statiques automatiquement
obtenues des applications.

Figure 24. Identification des instantanés de système d’exploitation et

applications pour lesquels exécuter les tests de correctifs
5. Les résultats sont affichés et enregistrés dans des rapports Web
(figure 25).

Les 20 commandements de l’intégration logicielle Page 29

 Figure 25. Affichage des rapports de tests de correctifs
Le gros avantage d’un outil de test de l’impact des correctifs comme
Patch Impact Manager est qu’il vous aide à cibler les applications
touchées par le correctif. Vous pouvez ensuite effectuer des tests de
correctifs supplémentaires pour les applications qui partagent des
informations de fichiers ou de registre avec le nouveau correctif, ce qui
rend le processus de test des correctifs beaucoup plus efficace.

20. Gérez l’intégration comme un projet

L’intégration logicielle est un processus qui suit des étapes spécifiques,

l’une après l’autre. Comme tous les processus, cette activité doit être
gérée comme un projet, avec des pratiques de gestion de projet saines.
Votre environnement d’intégration intégré doit apporter un soutien à la
gestion de projet solide et doit vous aider à suivre l’état du projet à tout
instant. Ainsi, vous pouvez non seulement créer des progiciels solides ne
nécessitant que peu d’assistance après déploiement, mais vous le faites
le plus efficacement possible.

AdminStudio, combiné avec AMS de Macrovision, fournit des

fonctionnalités clés pour la gestion des projets d’intégration. La première
s’appuie sur les rapports que vous pouvez générer avec AdminStudio.
Ces rapports portent sur chaque progiciel et fournissent des
informations complètes sur chaque progiciel (figure 26).

Les 20 commandements de l’intégration logicielle Page 30

 Figure 26. Création et archivage des rapports d’applications dans
AdminStudio

En outre, AMS complète les capacités d’AdminStudio en suivant

l’état de chaque progiciel au cours du processus de préparation. Cela
aide à considérer chaque demande d’intégration comme un projet. AMS
vous permet de générer des rapports sur la progression de toutes les
applications dans chaque projet (figure 27).

Figure 27. Utilisation d’AMS avec AdminStudio pour suivre l’état

du projet tout au long du processus d’intégration

Les 20 commandements de l’intégration logicielle Page 31

Conclusion
Et voilà ! 20 commandements qui devraient largement contribuer à
rendre vos progiciels plus propres et plus stables, réduisant ainsi les
problèmes pouvant survenir après le déploiement. Utilisez ces conseils
pratiques pour rendre vos progiciels meilleurs, plus propres et plus
stables. Bon nombre de ces commandements sont pris en charge
directement par les environnements d’intégration intégrés comme
indiqué dans ce document. Les autres sont simplement des normes que
vous devez mettre en place.
Apprenez-les tous et incorporez-les à votre stratégie d’intégration dès
aujourd’hui. Vous vous rendrez compte qu’avec l’environnement
d’intégration intégré approprié, dans ce cas AdminStudio, ces
commandements vous aideront à gagner un contrôle complet sur les
frais de propriété totaux des logiciels dans votre réseau.

Les 20 commandements de l’intégration logicielle Page 32