Archives de la catégorie ‘Microsoft’

L’administration d’un parc informatique important peut devenir une tâche ardue si le nombre de postes de travail est important ou s’ils sont répartis sur une zone géographique vaste.

Dans ce cas, vous avez 2 solutions majeures :

  • Le réseau « basket » : à l’aide d’une clé USB, d’un partage réseau et d’une bonne paire de chaussures de sports, votre rôle sera de vous connecter sur chaque poste de travail et de réaliser l’installation manuelle. J’oubliais que vous pouviez aussi vous connecter en prise de main à distance 🙂
  • Packager votre application et la proposer au déploiement : cette solution sera étudiée ci-dessous

1. Installation d’une application : description

L’installation d’une application se fait via l’exécution d’un programme exécutable (.exe) qui réalise différentes opérations :

  • Base de registre : ajout/modification de clés et de valeurs
  • Système de fichiers : ajout de fichiers selon une arborescence
  • Base de données de configuration logicielle Microsoft : ajout des informations sur l’application dans la base de données (Panneau de configuration/Ajout-suppression de programmes)

L’application se charge également de valider les pré-requis :

  • architecture CPU,
  • espace disque,
  • mémoire vive,
  • version d’IE,
  • version de .NET,

2. Pré-requis : le poste de travail source

Afin de packager l’application cible, vous devez vous appuyer sur un poste de travail type. Ce poste de travail doit contenir toutes les applications standards de votre entreprise, être intégrée à votre domaine Active Directory et connectée à votre réseau.

Vous devez être administrateur local de ce poste de travail.

Il doit également posséder 2 applications :

  • regshot : disponible ici
  • MSI Studio Pro : disponible ici

Votre poste de travail source peut également être, et je vous le conseille, une machine virtuelle.
Dans ce cas, avant toute modification, vous activerez les snapshots. Cette opération vous permettra de revenir facilement en arrière et retrouver un poste de travail source propre.

3. Cliché pré-installation de la base de registre

  1. Fermer toutes les applications ouvertes
  2. Exécuter l’application regshot.exe
    regshot1
  3. Ajouter un commentaire, ici : « Shot 1 : Application TEST »
  4. Cliquer sur le bouton <1st shot>, <Shot and save>
  5. Enregistrer le résultat dans un fichier, ici : TEST-Shot-1.hiv
  6. Fermer l’application

4. Installation de l’application cible

Installez votre à application.

Lors de l’installation, veillez tout de même à noter les différents chemins d’installation, les modifications réalisées sur l’arborescence du Menu Démarrer et les modifications apportées sur le bureau.

TESTEZ VOTRE NOUVELLE APPLICATION

5. Cliché post-installation de la base de registre

  1. Fermer toutes les applications ouvertes
  2. Exécuter l’application regshot.exe
    regshot1
  3. Ajouter un commentaire, ici : « Shot 2 : Application TEST »
  4. Cliquer sur le bouton <1st shot>, <Load> et sélectionner le fichier TEST-Shot-1.hiv
    regshot2
  5. Cliquer sur le bouton <2nd shot>, <shot>
    regshot3
  6. Cliquer sur le bouton <cOmpare>
    RegShot ouvre alors un fichier txt contenant les différences entre les 2 clichés. On y trouve en outre les clés et les valeurs ajoutées/modifiées/supprimées
  7. Enregistrer ce fichier résultat
  8. Fermer l’application

6. Packager l’application

  1. Ouvrez l’application MSI Studio Professional
  2. Sélectionnez « Create a New Setup Installation for a Sofware Program »
  3. Sélectionnez « Windows Template » puis cliquez sur « Open the new project directly »
  4. Configuration du projet (* = Obligatoire)
    Product Details – Name (*): saisissez le nom de l’application tel qu’il apparaitra sur le poste de travail
    Product Details – Version (*): saisissez le numéro de version
    Product Details – Manufacturer (*): saisissez l’éditeur du programme
    Product Details – Default Directory (*): sélectionnez le dossier de destination par défaut
    General Information – Title :
    General Information – Subject :
    General Information – Author : saisissez l’auteur du projet, c’est à dire vous
    General Information – Keywords :
    General Information – Comments :
    General Information – Package Code (*): cliquez sur le bouton <Create>, pour générer un identifiant unique
  5. Support et panneau de configuration
    Dans la zone « Add or Remove Programs », vous pouvez paramétrer l’intégration de votre nouvelle application dans le Panneau de configuration-Ajout/suppression de programmes de Windows.
    Les informations de support sont fortement recommandées. Support Information – Contact :  nom du chef de projet responsable de cette application
    Support Information – Phone Number : numéro de téléphone de votre centre de service ou de votre équipe support niveau 1
    Support Information – Support URL : URL d’accès à la page Web de support de votre application
  6. Applications Requirements
    Sélectionnez ici (si nécessaire) les versions minimales nécessaires à la bonne exécution de votre programme

    • Windows 9x
    • Windows NT
    • Internet explorer
    • .Net framework

    Sélectionnez ensuite (si nécessaire) les applications (fichiers .exe) nécessaires à la bonne exécution de votre programme cible.

    Si votre cible requière le framwork .Net, spécifiez le mode d’installation :

    • Run the .NET MSI from a UNC network or local path : si vous disposez d’un partage réseau contenant le fichier d’installation
    • Store the .NET Framework within the package : si vous souhaitez intégrer le pacage d’installation .NET dans votre propre package
  7. Installation Properties
    Configurez ici votre méthode d’installation (redémarrage, …)
  8. Files and Registry ( <— C’est ici que vous ajoutez les fichiers, registre et autres variables d’environnement de votre future application)
    1. Filesmsi1
      A partir de l’onglet « System View », sélectionnez le dossier d’installation de votre application source
      A partir de l’onglet « Project View », sélectionnez le dossier de destination
      Cliquez sur le bouton <Add Folder>
    2. Registry
      A partir du fichier issu de RegShot, sélectionnez les clés et les valeurs à ajouter
  9. Shortcuts and Other Items
    1. Shortcuts : ajoutez ici la création de raccourcis
    2. INI Files : ajoutez ici la création de fichier INI spécifique ou modifiez un fichier INI existant
    3. Environnement variables : ajoutez/modifiez des variables d’environnement (Poste de Travail/Propriété/Avancé/Variable d’environnement)
    4. Service Management : déterminez ici l’exécutable à configurer en tant que service et gérez son mode de démarrage
  10. Dialogs and Actions

    1. Dialogs : ici, vous pouvez ajouter/modifier les boites de dialogue prédéfinies dans l’application. En effet, un fichier MSI, tel une application, communique avec son utilisateur (licence, path, …).
    2. Dialog Sequencing : le séquencement des boites de dialogue peut être configuré
  11. A vos marques, prêts, …., packagez et testez
    Ctrl+B

7. Ajouter votre fichier MSI pour déploiement sur votre parc

Cette section est ou sera abordée dans l’article « Implémentation GLPI »

Publicités

###############################################################################
# Exemple usage (run from OpsMgr Command Shell):

#Get-OpsMgrWorkflows_v1.ps1 -agentname « myagent.contoso.com » | export-csv -path c:\temp\workflows.csv

###############################################################################

param ([string]$agentname = $(read-host « Please enter OpsMgr Agent Name »))

function Get-AgentWorkflow($agentname)
{

$taskobj = Get-Task | Where-Object {$_.Name -eq « Microsoft.SystemCenter.GetAllRunningWorkflows »}

# Grab HealthService class object
$hsobj = Get-MonitoringClass -name « Microsoft.SystemCenter.HealthService »
# Find HealthService object defined for named server
$monobj = Get-MonitoringObject -MonitoringClass $hsobj | Where-Object {$_.DisplayName -match $agentname}

#Start Task GetAllRunningWorkflows
$taskOut = Start-Task -Task $taskobj -TargetMonitoringObject $monobj
[xml]$taskXML = $taskOut.OutPut

#Get Workflows
$workflows=$taskXML.selectnodes(« /DataItem/Details/Instance/Workflow »)

#Retrieve Monitors
$monitors = get-monitor

#Retrieve Rules
$rules = get-rule

#Retrieve Discoveries »
#Used the Group-object because there are some discovery rules with the same DisplayName
$discoveries = get-discovery | select-object -Unique

#Get Overrides »
#monitoroverrides = foreach ($monitor in Get-ManagementPack | get-override | where {$_.monitor}) {get-monitor | where {$_.Id -eq $monitor.monitor.id}}
#$rulesoverrides = foreach ($rule in Get-ManagementPack | get-override | where {$_.rule}) {get-rule | where {$_.Id -eq $rule.rule.id}}
#$discoveryoverrides = foreach ($discovery in Get-ManagementPack | get-override | where {$_.discovery}) {get-discovery | where {$_.Id -eq $discovery.discovery.id}}

#Check for each workflow if it’s a Rule or Monitor or Discovery.
foreach ($workflow in $workflows)
{
#Check for Monitor
$monitor = $monitors | where-object {$_.Name -eq $workflow. »#text »}

if ($monitor -eq $null)
{
#Check for Rule
$rule = $rules | where-object {$_.Name -eq $workflow. »#text »}
if ($rule -eq $null)
{
#Check for Discovery
$discovery = $discoveries | where-object {$_.Name -eq $workflow. »#text »}
if ($discovery -eq $null)
{

}
else
{
#Get ManagementPack
$mp = $discovery.getmanagementpack()
#Check if Discovery has an override
#$flag = $discoveryoverrides | Where-Object {$_.DisplayName -eq $discovery.DisplayName}
#if ($flag -eq $null)
#{
#    $override = « false »
#}
#else
#{
#    $override = « true »
#}
$discobject = new-object System.Management.Automation.PSObject
$discobject = $discobject | add-member -membertype NoteProperty -name Type -value « Discovery » -passthru
$discobject = $discobject | add-member -membertype NoteProperty -name DisplayName -value $discovery.DisplayName -passthru
$discobject = $discobject | add-member -membertype NoteProperty -name Description -value $discovery.Description -passthru
#$discobject = $discobject | add-member -membertype NoteProperty -name Override -value $override -passthru
$discobject = $discobject | add-member -membertype NoteProperty -name ManagementPack -value $mp.DisplayName -passthru
$discobject
}
}
else
{
$mp = $rule.getmanagementpack()
#Check if Rule has an override
#$flag = $ruleoverrides | Where-Object {$_.DisplayName -eq $rule.DisplayName}
#if ($flag -eq $null)
#{
#    $override = « false »
#}
#else
#{
#    $override = « true »
#}
$ruleobject = new-object System.Management.Automation.PSObject
$ruleobject = $ruleobject | add-member -membertype NoteProperty -name Type -value « Rule » -passthru
$ruleobject = $ruleobject | add-member -membertype NoteProperty -name DisplayName -value $rule.DisplayName -passthru
$ruleobject = $ruleobject | add-member -membertype NoteProperty -name Description -value $rule.Description -passthru
#$ruleobject = $ruleobject | add-member -membertype NoteProperty -name Override -value $override -passthru
$ruleobject = $ruleobject | add-member -membertype NoteProperty -name ManagementPack -value $mp.DisplayName -passthru
$ruleobject
}
}
else
{
#Get ManagementPack for Monitor
$mp = $monitor.getmanagementpack()
#Check if Monitor has an override
#$flag = $monitoroverrides | Where-Object {$_.DisplayName -eq $monitor.DisplayName}
#if ($flag -eq $null)
#{
#    $override = « false »
#}
#else
#{
#    $override = « true »
#}
$monitorobject = new-object System.Management.Automation.PSObject
$monitorobject = $monitorobject | add-member -membertype NoteProperty -name Type -value « Monitor » -passthru
$monitorobject = $monitorobject | add-member -membertype NoteProperty -name DisplayName -value $monitor.DisplayName -passthru
$monitorobject = $monitorobject | add-member -membertype NoteProperty -name Description -value $monitor.Description -passthru
#$monitorobject = $monitorobject | add-member -membertype NoteProperty -name Override -value $override -passthru
$monitorobject = $monitorobject | add-member -membertype NoteProperty -name ManagementPack -value $mp.DisplayName -passthru
$monitorobject
}
}

}

Get-AgentWorkflow $agentname