Publication d'application et interaction du client

Mis à jour: décembre 2014

S'applique à: Application Virtualization 5.0, Application Virtualization 5.0 SP1, Application Virtualization 5.0 SP2, Application Virtualization 5.0 SP3

Cet article fournit des informations techniques sur les opérations courantes du client App-V et leur intégration au système d'exploitation local.

• Fichiers du package App-V créés par Sequencer

• Nouveautés du fichier appv

• Emplacements de stockage des données du client App-V

• Registre de package

• Comportement du magasin de packages App-V

• Itinérance du Registre et des données

• Gestion du cycle de vie des applications du client App-V

• Intégration de packages App-V

• Traitement de la configuration dynamique

• Assemblys côte à côte

• Journalisation des clients

Pour plus d'informations, consultez la page de téléchargement de ressources de la documentation de Microsoft Application Virtualization (App-V).

Fichiers du package App-V créés par Sequencer

Sequencer crée les packages App-V et génère une application virtualisée. Le processus de séquencement crée les fichiers suivants :

Fichier	Description
.appv	Fichier de package principal, qui contient les composants capturés et les informations d'état du processus de séquencement. Architecture du fichier de package, informations de publication et Registre présentés sous forme de jeton pouvant être réappliqué à un ordinateur et à un utilisateur spécifique lors de la livraison.
.MSI	Wrapper de déploiement exécutable que vous pouvez utiliser pour déployer des fichiers .appv manuellement ou à l'aide d'une plateforme tierce de déploiement.
_DeploymentConfig.XML	Fichier utilisé pour personnaliser les paramètres de publication par défaut de toutes les applications d'un package déployé globalement pour tous les utilisateurs sur un ordinateur qui exécute le client App-V.
_UserConfig.XML	Fichier utilisé pour personnaliser les paramètres de publication de toutes les applications d'un package déployé pour un utilisateur spécifique sur un ordinateur qui exécute le client App-V.
Report.xml	Résumé des messages résultant du processus de séquencement, y compris les emplacements omis des pilotes, des fichiers et du Registre.
.CAB	Facultatif : fichier d'accélérateur de package utilisé pour régénérer automatiquement un package d'application virtuelle précédemment séquencé.
.appvt	Facultatif : fichier de modèle de Sequencer utilisé pour conserver les paramètres fréquemment réutilisés de Sequencer.

Pour plus d'informations sur le séquencement, consultez le guide de séquencement d'Application Virtualization 5.0.

Nouveautés du fichier appv

Le fichier appv est un conteneur qui stocke les fichiers XML et non XML dans une seule entité. Ce fichier est généré à partir du format AppX, basé sur la norme Open Packaging Conventions (OPC).

Pour afficher le contenu du fichier appv, faites une copie du package et remplacez l'extension du fichier copié par .ZIP.

Le fichier appv contient les dossiers et fichiers suivants, utilisés pour la création et la publication d'une application virtuelle :

Nom	Type	Description
Racine	Dossier de fichiers	Répertoire contenant le système de fichiers pour l'application virtualisée capturée pendant le séquencement.
[Content_Types].xml	Fichier XML	Liste des types de contenu principaux du fichier appv (par exemple, DLL, EXE, BIN)
AppxBlockMap.xml	Fichier XML	Mise en page du fichier appv, qui utilise des éléments File, Block et BlockMap pour placer et valider les fichiers dans le package App-V.
AppxManifest.xml	Fichier XML	Métadonnées du package contenant les informations requises pour ajouter, publier et lancer le package. Inclut des points d'extension (associations de types de fichiers et raccourcis) ainsi que les noms et GUID associés au package.
FilesystemMetadata.xml	Fichier XML	Liste des fichiers capturés pendant le séquencement, y compris les attributs (par exemple, répertoires, fichiers, répertoires opaques, répertoires vides et noms longs et courts).
PackageHistory.xml	Fichier XML	Informations sur l'ordinateur de séquencement (version du système d'exploitation, version d'Internet Explorer, version du .Net Framework) et le processus (mise à niveau, version du package).
Registry.dat	Fichier DAT	Clés et valeurs de Registre capturées pendant le processus de séquencement du package.
StreamMap.xml	Fichier XML	Liste des fichiers du bloc de fonctionnalité principal et de publication. Le bloc de fonctionnalité de publication contient les fichiers ICO et les parties requises des fichiers (EXE et DLL) pour la publication du package. Lorsqu'il est présent, le bloc de fonctionnalité principal inclut des fichiers optimisés pour la diffusion en continu pendant le processus de séquencement.

Emplacements de stockage des données du client App-V

Le client App-V exécute des tâches pour faire en sorte que les applications virtuelles s'exécutent correctement et fonctionnent comme des applications installées localement. Le processus d'ouverture et d'exécution des applications virtuelles requiert un mappage du système de fichiers virtuel et du Registre pour s'assurer que l'application possède les composants requis d'une application traditionnelle que les utilisateurs attendent. Cette section décrit les composants requis pour exécuter des applications virtuelles et indique l'emplacement où App-V stocke ces composants.

Nom	Emplacement	Description
Magasin de packages	%ProgramData%\App-V	Emplacement par défaut des fichiers de package en lecture seule.
Catalogue de l'ordinateur	%ProgramData%\Microsoft\AppV\Client\Catalog	Contient les documents de configuration par ordinateur
Catalogue de l'utilisateur	%AppData%\Microsoft\AppV\Client\Catalog	Contient les documents de configuration par utilisateur
Sauvegardes de raccourcis	%AppData%\Microsoft\AppV\Client\Integration\ShortCutBackups	Stocke les points d'intégration précédents qui permettent une restauration lors de l'annulation de la publication du package.
Itinérance de copie pour écriture	%AppData%\Microsoft\AppV\Client\VFS	Emplacement de l'itinérance inscriptible pour la modification du package.
Copie pour écriture locale	%LocalAppData%\Microsoft\AppV\Client\VFS	Emplacement de la non-itinérance inscriptible pour la modification du package.
Registre de l'ordinateur	HKLM\Software\Microsoft\AppV	Contient les informations d'état du package, notamment VReg pour les packages publiés sur l'ordinateur ou globalement (ruche d'ordinateurs)
Registre de l'utilisateur	HKCU\Software\Microsoft\AppV	Contient les informations d'état des packages de l'utilisateur, notamment VReg.
Classes du Registre de l'utilisateur	HKCU\Software\Classes\AppV	Contient les informations d'état des autres packages de l'utilisateur.

Des détails supplémentaires pour le tableau sont fournis dans la section ci-dessous et dans tout le document.

Magasin de packages

Le Client App-V gère les composants d'applications montés dans le magasin de packages. Cet emplacement de stockage par défaut est %ProgramData%\App-V, mais vous pouvez le configurer pendant ou après l'installation à l'aide de la commande PowerShell Set-AppVClientConfiguration, qui modifie le Registre local (valeur PackageInstallationRoot sous la clé HKLM\Software\Microsoft\AppV\Client\Streaming). Le magasin de packages doit se trouver dans un chemin d'accès local sur le système d'exploitation client. Les packages individuels sont stockés dans le magasin de packages dans des sous-répertoires nommés d'après le GUID du package et le GUID de la version.

Exemple de chemin d'accès à une application spécifique :

C:\ProgramData\App-V\PackGUID\VersionGUID 

Pour modifier l'emplacement par défaut du magasin de packages pendant l'installation, consultez Comment déployer le client App-V.

Magasin de contenu partagé

Si le client App-V est configuré en mode Magasin de contenu partagé, aucune donnée n'est écrite sur le disque quand une erreur de flux se produit, ce qui signifie que les packages nécessitent un espace disque minimal (publication de données). L'utilisation d'un espace disque moindre est vivement recommandé dans les environnements VDI, où le stockage local peut être limité, et il est recommandé de diffuser en continu les applications à partir d'un emplacement réseau à performances élevées (par exemple, un réseau SAN). Pour plus d'informations sur le mode Magasin de contenu partagé, consultez https://go.microsoft.com/fwlink/p/?LinkId=392750.

Notes

L'ordinateur et le magasin de packages doivent se trouver sur un lecteur local, même quand vous utilisez des configurations Magasin de contenu partagé pour le client App-V.

Catalogues de packages

Le client App-V gère les deux emplacements de fichiers suivants :

• Catalogues (utilisateur et ordinateur).

• Emplacements du Registre, selon la façon dont le package est ciblé pour la publication. Il existe un catalogue (magasin de données) pour l'ordinateur et un pour chaque utilisateur. Le catalogue de l'ordinateur stocke les informations globales applicables à tous les utilisateurs, tandis que le catalogue de l'utilisateur stocke des informations applicables à un utilisateur spécifique. Le catalogue est une collection de configurations dynamiques et de fichiers manifestes. Des données discrètes se trouvent à la fois dans les fichiers et le Registre pour chaque version du package.

Catalogue de l'ordinateur

Description	Stocke les documents de package disponibles pour les utilisateurs sur l'ordinateur, quand des packages sont ajoutés et publiés. Toutefois, si un package est « global » au moment de la publication, les intégrations sont disponibles pour tous les utilisateurs. Si un package n'est pas global, les intégrations sont publiées uniquement pour des utilisateurs spécifiques, mais il existe quand même des ressources globales qui sont modifiées et visibles par toute personne sur l'ordinateur client (par exemple, le répertoire du package est dans un emplacement de disque partagé). Si un package est disponible pour un utilisateur sur l'ordinateur (global ou non), le manifeste est stocké dans le catalogue de l'ordinateur. Quand un package est publié globalement, il existe un fichier de configuration dynamique, stocké dans le catalogue de l'ordinateur. Par conséquent, déterminer si un package est global ou non revient à déterminer s'il existe un fichier de stratégie (fichier UserDeploymentConfiguration) dans le catalogue de l'ordinateur.
Emplacement de stockage par défaut	%programdata%\Microsoft\AppV\Client\Catalog\ Cet emplacement n'est pas identique à celui du magasin de packages. Le magasin de packages est la copie d'origine des fichiers du package.
Fichiers du catalogue de l'ordinateur	Manifest.xml DeploymentConfiguration.xml UserManifest.xml (package publié globalement) UserDeploymentConfiguration.xml (package publié globalement)
Emplacement supplémentaire du catalogue de l'ordinateur, utilisé quand le package fait partie d'un groupe de connexion	L'emplacement suivant s'ajoute à l'emplacement du package spécifique mentionné ci-dessus : %programdata%\Microsoft\AppV\Client\Catalog\PackageGroups\ConGroupGUID\ConGroupVerGUID
Fichiers supplémentaires dans le catalogue de l'ordinateur quand le package fait partie d'un groupe de connexion	PackageGroupDescriptor.xml UserPackageGroupDescriptor.xml (groupe de connexion publié globalement)

Catalogue de l'utilisateur

Description	Créé pendant le processus de publication. Contient des informations utilisées pour la publication du package ainsi que pendant le lancement pour s'assurer qu'un package est configuré pour un utilisateur spécifique. Créé dans un emplacement itinérant, inclut des informations de publication propres à l'utilisateur. Quand un package est publié pour un utilisateur, le fichier de stratégie est stocké dans le catalogue de l'utilisateur. En même temps, une copie du manifeste est également stockée dans le catalogue de l'utilisateur. Quand un droit d'accès à un package est supprimé pour un utilisateur, les fichiers du package correspondant sont supprimés du catalogue de l'utilisateur. En examinant le catalogue de l'utilisateur, un administrateur peut voir s'il existe un fichier de configuration dynamique, ce qui indique que le package est autorisé pour cet utilisateur. Pour les utilisateurs itinérants, le catalogue de l'utilisateur doit être à un emplacement partagé ou itinérant pour conserver le comportement App-V hérité de ciblage des utilisateurs par défaut. Le droit d'accès et la stratégie sont liés à un utilisateur et non à un ordinateur. Ainsi, une fois approvisionnés, ils doivent se déplacer avec l'utilisateur.
Emplacement de stockage par défaut	ppdata\roaming\Microsoft\AppV\Client\Catalog\Packages\PkgGUID\VerGUID
Fichiers du catalogue de l'utilisateur	UserManifest.xml DynamicConfiguration.xml ou UserDeploymentConfiguration.xml
Emplacement supplémentaire du catalogue de l'utilisateur, utilisé quand le package fait partie d'un groupe de connexion	L'emplacement suivant s'ajoute à l'emplacement du package spécifique mentionné ci-dessus : appdata\roaming\Microsoft\AppV\Client\Catalog\PackageGroups\PkgGroupGUID\PkgGroupVerGUID
Fichier supplémentaire dans le catalogue de l'ordinateur quand le package fait partie d'un groupe de connexion	UserPackageGroupDescriptor.xml

Sauvegardes de raccourcis

Pendant le processus de publication, le client App-V sauvegarde les raccourcis et les points d'intégration dans %AppData%\Microsoft\AppV\Client\Integration\ShortCutBackups.. Cette sauvegarde permet de restaurer les anciennes versions de ces points d'intégration quand la publication du package est annulée.

Fichiers de copie pour écriture

Le magasin de packages contient la copie d'origine des fichiers du package qui ont été diffusés en continu à partir du serveur de publication. Quand une application App-V fonctionne correctement, l'utilisateur ou le service peuvent avoir besoin de modifier des fichiers. Ces modifications ne sont pas répercutées dans le magasin de packages pour vous laisser la possibilité de réparer l'application, ce qui revient à supprimer ces modifications. Ces emplacements, appelés copie pour écriture, prennent en charge les emplacements à la fois itinérants et non itinérants. L'emplacement de stockage des modifications dépend de l'emplacement auquel l'application a été programmée pour écrire les modifications dans un environnement natif.

Itinérance de copie pour écriture

L'emplacement de l'itinérance de copie pour écriture ci-dessus stocke les modifications apportées aux fichiers et répertoires ciblés à l'emplacement habituel %AppData% ou \Users\{nom_utilisateur}\AppData\Roaming. Ces répertoires et fichiers sont alors déplacés en fonction des paramètres du système d'exploitation.

Copie pour écriture locale

L'emplacement de la copie pour écriture locale est similaire à l'emplacement de l'itinérance, mais les fichiers et répertoires ne sont pas déplacés vers d'autres ordinateurs, même si la prise en charge de l'itinérance a été configurée. L'emplacement de la copie pour écriture locale, décrit ci-dessus, stocke les modifications applicables aux emplacements Windows standard et non à l'emplacement %AppData%. Les répertoires indiqués varient, mais il existe deux emplacements Windows standard (Common AppData et Common AppDataS). Le S désigne l'emplacement limité quand le service virtuel demande la modification en tant qu'utilisateur avec élévation de privilèges autre que les utilisateurs connectés. L'emplacement sans S stocke les modifications basées sur l'utilisateur.

Registre de package

Pour qu'une application puisse accéder aux données du Registre de package, le client App-V doit les rendre disponibles. Le client App-V utilise le Registre réel comme magasin de stockage pour toutes les données du Registre.

Quand un nouveau package est ajouté au client App-V, une copie du fichier REGISTRY.DAT du package est créée à l'emplacement %ProgramData%\Microsoft\AppV\Client\VREG\{Version GUID}.dat. Le nom du fichier correspond au GUID de la version avec l'extension DAT. Cette copie est effectuée pour garantir que le fichier ruche réel dans le package n'est jamais utilisé, ce qui empêcherait la suppression ultérieure du package.

Registry.dat du magasin de packages

>

%ProgramData%\Microsoft\AppV\Client\Vreg\{VersionGuid}.dat

Quand la première application du package est lancée sur le client, le client effectue une copie intermédiaire ou une copie du contenu du fichier ruche, ce qui permet de recréer les données du Registre de package à un autre emplacement HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AppV\Client\Packages\PackageGuid\Versions\VersionGuid\REGISTRY. Les données de Registre intermédiaires possèdent deux types distincts de données ordinateur et données utilisateur. Les données ordinateur sont partagées par tous les utilisateurs sur l'ordinateur. Les données utilisateur sont placées dans une copie intermédiaire pour chaque utilisateur à un emplacement qui lui est propre comme HKCU\Software\Microsoft\AppV\Client\Packages\PackageGuid\Registry\User. Les données ordinateur sont finalement supprimées au moment de la suppression du package et les données utilisateur sont supprimées lors de l'annulation de la publication par l'utilisateur.

Copie intermédiaire du Registre de package par et du Registre du groupe de connexion

Quand des groupes de connexion sont présents, le processus précédent de copie intermédiaire du Registre a toujours lieu, mais au lieu de traiter un seul fichier, il en traite plusieurs. Les fichiers sont traités dans l'ordre dans lequel ils apparaissent dans le fichier XML du groupe de connexion, le premier enregistreur remportant tous les conflits.

Le Registre intermédiaire persiste de la même façon que dans le cas d'un package unique. Les données de Registre intermédiaires de l'utilisateur restent pour le groupe de connexion tant qu'il n'est pas désactivé ; celles de l'ordinateur sont supprimées lors de la suppression du groupe de connexion.

Registre virtuel

L'objectif du registre virtuel (VREG) est de fournir un affichage fusionné unique du Registre de package et du registre natif aux applications. Il fournit également une fonctionnalité de copie pour écriture, à savoir que toutes les modifications apportées au registre à partir du contexte d'un processus virtuel le sont à un emplacement de copie pour écriture distinct. Cela signifie que le VREG doit combiner jusqu'à trois emplacements de Registre distincts dans une seule vue, basés sur les emplacements renseignés dans le Registre : copie pour écriture -> package -> natif. Quand une demande de données de Registre est faite, il localise dans l'ordre jusqu'à ce qu'il trouve les données demandées. Cela signifie que s'il existe une valeur stockée dans un emplacement de copie pour écriture, il ne passe pas aux autres emplacements. Cependant, si aucune donnée ne se trouve à l'emplacement de la copie pour écriture, il passe au package, puis à l'emplacement natif jusqu'à ce qu'il trouve les données appropriées.

Emplacements de registre

Il existe deux emplacements de Registre de package et deux emplacements de groupe de connexion où le client App-V stocke des informations de registre, selon que le package est publié individuellement ou dans le cadre d'un groupe de connexion. Il existe trois emplacements de copie pour écriture pour les packages et trois pour les groupes de connexion, qui sont créés et gérés par le VREG. Les paramètres pour les packages et les groupes de connexion ne sont pas partagés :

VReg de package unique :

Emplacement	Description
Copie pour écriture	Machine Registry\Client\Packages\PkgGUID\REGISTRY (Seul le processus avec élévation de privilèges peut écrire.) User Registry\Client\Packages\PkgGUID\REGISTRY (L'utilisateur déplace tout ce qui est écrit sous HKCU sauf Software\Classes.) User Registry Classes\Client\Packages\PkgGUID\REGISTRY (HKCU\Software\Classes pour l'écriture et HKLM pour le processus sans élévation de privilèges)
Package	Machine Registry\Client\Packages\PkgGUID\Versions\VerGuid\Registry\Machine User Registry Classes\Client\Packages\PkgGUID\Versions\VerGUID\Registry
Natif	Emplacement de registre d'application native

 

VReg de groupe de connexion :

Emplacement	Description
Copie pour écriture	Machine Registry\Client\PackageGroups\GrpGUID\REGISTRY (Seul le processus avec élévation de privilèges peut écrire.) User Registry\Client\PackageGroups\GrpGUID\REGISTRY (Tout ce qui est écrit dans HKCU sauf Software\Classes) User Registry Classes\Client\PackageGroups\GrpGUID\REGISTRY
Package	Machine Registry\Client\PackageGroups\GrpGUID\Versions\VerGUID\REGISTRY User Registry Classes\Client\PackageGroups\GrpGUID\Versions\VerGUID\REGISTRY
Natif	Emplacement de registre d'application native

 

Il existe deux emplacements de copie pour écriture pour les processus avec et sans élévation de privilèges HKLM. Les processus avec élévation de privilèges écrivent toujours les modifications HKLM dans la copie pour écriture sécurisée sous HKLM. Les processus sans élévation de privilèges écrivent toujours les modifications HKLM dans la copie pour écriture non sécurisée sous HKLM\Software\Classes. Quand une application lit des modifications dans HKLM, les processus avec élévation de privilèges les lisent à partir de la copie pour écriture sécurisée sous HKLM. Les processus sans élévation de privilèges les lisent à partir des deux emplacement, en favorisant d'abord celles apportées dans la copie pour écriture non sécurisée.

Clés directes

Les clés directes permettent à un administrateur de configurer certaines clés afin qu'elles ne soient lisibles qu'à partir du registre natif, ignorant les emplacements de package et de copie pour écriture. Les emplacements directs sont généraux pour l'ordinateur (et non propres à un package) et peuvent être configurés en ajoutant le chemin d'accès à la clé, qui doit être traitée comme un transfert direct à la valeur REG_MULTI_SZ appelée PassThroughPaths de la clé HKLM\Software\Microsoft\AppV\Subsystem\VirtualRegistry. Toute clé qui apparaît sous cette valeur de chaînes multiples (et ses enfants) est considérée comme un transfert direct.

Les emplacements suivants sont configurés en tant qu'emplacements directs par défaut :

• HKEY_CURRENT_USER\SOFTWARE\Classes\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel

• HKEY_LOCAL_MACHINE\SOFTWARE\Classes\Local Settings\Software\Microsoft\Windows\CurrentVersion\AppModel

• HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\WINEVT

• HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\eventlog\Application

• HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\WMI\Autologger

• HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet Settings

• HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib

• HKEY_LOCAL_MACHINE\SOFTWARE\Policies

• HKEY_CURRENT_USER\SOFTWARE\Policies

Le rôle des clés directes est de veiller à ce qu'aucune application virtuelle n'écrive des données de registre dans le VReg requis pour les applications non virtuelles afin d'en assurer le bon fonctionnement ou la bonne intégration. La clé Policies garantit l'utilisation des paramètres de stratégie de groupe définis par l'administrateur au lieu des paramètres de package. La clé AppModel est requise pour l'intégration dans les applications à interface utilisateur moderne Windows. Nous recommandons aux administrateurs de ne pas modifier les clés directes par défaut, mais dans certains cas, le comportement de certaines applications peut demander d'ajouter des clés directes supplémentaires.

Comportement du magasin de packages App-V

App-V 5 gère le magasin de packages, qui est l'emplacement où sont stockés les fichiers de composants développés à partir du fichier appv. Par défaut, cet emplacement se trouve dans %ProgramData%\App-V et ses fonctionnalités de stockage ne sont limitées que par l'espace disque libre. Le magasin de packages est organisé par les GUID du package et de la version, comme indiqué dans la section précédente.

Ajouter des packages

Des copies intermédiaires des packages App-V sont effectuées lors de l'ajout à l'ordinateur avec le client App-V. Le client App-V fournit les copies intermédiaires à la demande. Lors de la publication ou de l'exécution manuelle d'une applet de commande Add-AppVClientPackage, la structure de données est générée dans le magasin de packages (c:\programdata\App-V\{PkgGUID}\{VerGUID}). Les fichiers du package identifiés dans le bloc de publication défini dans le fichier StreamMap.xml sont ajoutés au système et les copies intermédiaires des dossiers de niveau supérieur et des fichiers enfants sont créés pour veiller à ce que les composants d'application appropriés existent au lancement.

Montage des packages

Les packages peuvent être chargées explicitement à l'aide de l'applet de commande PowerShell Mount-AppVClientPackage ou à l'aide de l'interface utilisateur du client App-V pour télécharger un package. Cette opération charge complètement l'ensemble du package dans le magasin de packages.

Diffusion en continu de packages

Le client App-V peut être configuré pour modifier le comportement par défaut de diffusion en continu. Toutes les stratégies de diffusion en continu sont stockées sous la clé de Registre suivante : HKEY_LOCAL_MAcHINE\Software\Microsoft\AppV\Client\Streaming. Les stratégies sont définies à l'aide de l'applet de commande PowerShell Set-AppvClientConfiguration. Les stratégies suivantes s'appliquent à la diffusion en continu :

Stratégie	Description
AllowHighCostLaunch	Sur Windows 8, cette stratégie permet la diffusion en 3G et sur les réseaux cellulaires.
AutoLoad	Spécifie le paramètre de chargement en arrière-plan : 0 - Désactivé 1 - Packages précédemment utilisés uniquement 2 - Tous les packages
PackageInstallationRoot	Dossier racine du magasin de packages sur l'ordinateur local
PackageSourceRoot	Remplacement de la racine où les packages doivent être diffusés en continu
SharedContentStoreMode	Permet l'utilisation du magasin de contenu partagé pour les scénarios VDI.

 

Ces paramètres affectent le comportement de diffusion en continu des composants de package App-V sur le client. Par défaut, App-V télécharge uniquement les composants requis après le téléchargement du bloc de publication initiale et du bloc de fonctionnalité principal. Il existe trois comportements spécifiques à expliquer autour de la diffusion en continu des packages :

• Diffusion en continu en arrière-plan

• Diffusion en continu optimisée

• Erreurs de flux

Diffusion en continu en arrière-plan

L'applet de commande PowerShell Get-AppvClientConfiguration peut servir à déterminer le mode actuel de diffusion en continu en arrière-plan avec le paramètre AutoLoad et à le modifier avec l'applet de commande Set-AppvClientConfiguration ou à partir du Registre (clé HKLM\SOFTWARE\Microsoft\AppV\ClientStreaming). La diffusion en continu en arrière-plan est un paramètre par défaut pour lequel le paramètre AutoLoad est défini pour télécharger les packages précédemment utilisés. Le comportement basé sur le paramètre par défaut (valeur=1) télécharge les blocs de données App-V en arrière-plan après le lancement de l'application. Ce paramètre peut être désactivé dans son ensemble (valeur=0) ou activé pour tous les packages (valeur=2), qu'ils soient lancés ou non.

Diffusion en continu optimisée

Les packages App-V peuvent être configurés avec un bloc de fonctionnalité principal lors du séquencement. Ce paramètre permet à l'ingénieur de séquencement d'analyser les fichiers de démarrage d'une ou plusieurs applications spécifiques, puis de marquer les blocs de données dans le package App-V pour la diffusion en continu au premier lancement de l'une des applications dans le package.

Erreurs de flux

Après le flux initial des données de publication et du bloc de fonctionnalité principal, les demandes de fichiers supplémentaires génèrent des erreurs de flux. Ces blocs de données sont téléchargés vers le magasin de packages en fonction des besoins. Cela permet à un utilisateur de télécharger uniquement une petite partie du package, généralement suffisante pour lancer le package et exécuter des tâches normales. Tous les autres blocs sont téléchargées quand un utilisateur lance une opération qui requiert des données qui ne sont actuellement pas dans le magasin de packages.

Pour plus d'informations sur la diffusion en continu du package App-V, visitez : https://go.microsoft.com/fwlink/?LinkId=392770.

Le séquencement pour l'optimisation de la diffusion en continu est disponible à l'adresse : https://go.microsoft.com/fwlink/?LinkId=392771.

Mises à niveau des packages

Les packages App-V ont besoin d'être mis à jour tout au long du cycle de vie de l'application. Les mises à niveau de packages App-V sont similaires à l'opération de publication des packages, puisque chaque version est créée à son propre emplacement PackageRoot : %ProgramData%\App-V\{PkgGUID}\{newVerGUID}. L'opération de mise à niveau est optimisée par la création de liens physiques vers des fichiers identiques (et diffusés en continu) d'autres versions du même package.

Suppression des packages

Le comportement du client App-V quand des packages sont supprimés dépend de la méthode utilisée pour la suppression. À l'aide d'une infrastructure complète App-V pour annuler la publication de l'application, les fichiers du catalogue de l'utilisateur (catalogue de l'ordinateur pour les applications publiées globalement) sont supprimés, mais l'emplacement du magasin de packages et les emplacements de copie pour écriture sont conservés. Quand l'applet de commande PowerShell Remove-AppVClientPackge est utilisée pour supprimer un package App-V, l'emplacement du magasin de packages est nettoyé. N'oubliez pas que l'annulation de la publication un package App-V sur le serveur d'administration n'effectue pas d'opération de suppression. Aucune opération ne supprime les fichiers de package du magasin de packages.

Itinérance du Registre et des données

App-V 5 est capable de fournir une expérience quasi-native lors de l'itinérance, selon la manière dont l'application utilisée est écrite. Par défaut, App-V déplace AppData qui est stocké dans l'emplacement itinérant, selon la configuration itinérante du système d'exploitation. D'autres emplacements de stockage des données de fichiers ne se déplacent pas d'un ordinateur à l'autre, puisqu'il s'agit d'emplacements qui ne sont pas itinérants.

Conditions requises pour l'itinérance et stockage des données du catalogue de l'utilisateur

App-V stocke les données, qui représentent l'état du catalogue de l'utilisateur, sous la forme de :

• fichiers sous %appdata%\Microsoft\AppV\Client\Catalog ;

• paramètres de Registre sous HKEY_CURRENT_USER\Software\Microsoft\AppV\Client\Packages.

Ensemble, ces fichiers et paramètres de Registre représentent le catalogue de l'utilisateur, donc soit les deux doivent être itinérants, soit aucun des deux ne doit être itinérant pour un utilisateur donné. App-V ne prend pas en charge l'itinérance de %AppData%, mais la non-itinérance du profil de l'utilisateur (registre), ou vice versa.

Notes

L'applet de commande Repair-AppvClientPackage ne répare pas l'état de publication des packages, où l'état App-V de l'utilisateur sous HKEY_CURRENT_USER est manquant ou incompatible avec les données dans %appdata%.

Données du registre

L'itinérance du registre App-V s'illustre dans deux scénarios, comme indiqué dans le tableau suivant.

Scénario	Description
Applications exécutées en tant qu'utilisateurs standard	Quand un utilisateur standard lance une application App-V, HKLM et HKCU des applications App-V sont stockées dans la ruche HKCU sur l'ordinateur. Celle-ci se présente sous la forme de deux chemins distincts : HKLM : HKCU\SOFTWARE\Classes\AppV\Client\Packages\{PkgGUID}\REGISTRY\MACHINE\SOFTWARE HKCU : HKCU\SOFTWARE\Microsoft\AppV\Client\Packages\{PkgGUID}\REGISTRY\USER\{UserSID}\SOFTWARE Les emplacements sont activés pour l'itinérance selon les paramètres de système d'exploitation.
Applications exécutées avec élévation de privilèges	Quand une application est lancée avec élévation de privilèges : Les données HKLM sont stockées dans la ruche HKLM sur l'ordinateur local. Les données HKCU sont stockées à l'emplacement du Registre de l'utilisateur. Dans ce scénario, ces paramètres ne sont pas itinérants avec des configurations de l'itinérance du système d'exploitation normales et les clés et valeurs de Registre obtenues sont stockées à l'emplacement suivant : HKLM\SOFTWARE\Microsoft\AppV\Client\Packages\{PkgGUID}\{UserSID}\REGISTRY\MACHINE\SOFTWARE HKCU\SOFTWARE\Microsoft\AppV\Client\Packages\{PkgGUID}\Registry\User\{UserSID}\SOFTWARE

App-V et redirection de dossiers

App-V 5.0 SP2 prend en charge la redirection du dossier AppData itinérant (%AppData%). Au démarrage de l'environnement virtuel, l'état AppData itinérant du répertoire AppData itinérant de l'utilisateur est copié dans le cache local. Inversement, en cas d'arrêt de l'environnement virtuel, le cache local associé au répertoire AppData itinérant d'un utilisateur spécifique est transféré vers l'emplacement réel de ce répertoire.

Un package normal possède plusieurs emplacements mappés dans le magasin de stockage de l'utilisateur pour des paramètres compris dans AppData\Local et AppData\Roaming. Ces emplacements sont les emplacements de copie pour écriture stockés par utilisateur dans le profil de l'utilisateur et utilisés pour stocker les modifications apportées aux répertoires VFS du package et protéger le système VFS du package par défaut.

Le tableau suivant présente les emplacements locaux et itinérants, quand la redirection de dossiers n'a pas été implémentée.

Répertoire VFS dans le package	Emplacement mappé du magasin de stockage
ProgramFilesX86	C:\users\jsmith\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\ProgramFilesX86
SystemX86	C:\users\jsmith\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\SystemX86
Windows	C:\users\jsmith\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\Windows
appv_ROOT	C:\users\jsmith\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\appv_ROOT
AppData	C:\users\jsmith\AppData\Roaming\Microsoft\AppV\Client\VFS\<GUID>\AppData

 

Le tableau suivant présente les emplacements locaux et itinérants, quand la redirection de dossiers a été implémentée pour %AppData% et que l'emplacement a été redirigé (généralement vers un emplacement réseau).

Répertoire VFS dans le package	Emplacement mappé du magasin de stockage
ProgramFilesX86	C:\users\jsmith\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\ProgramFilesX86
SystemX86	C:\users\jsmith\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\SystemX86
Windows	C:\users\jsmith\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\Windows
appv_ROOT	C:\users\jsmith\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\appv_ROOT
AppData	\\Fileserver\users\jsmith\roaming\Microsoft\AppV\Client\VFS\<GUID>\AppData

 

Le pilote VFS du client App-V actuel ne peut pas écrire sur des emplacements réseau, donc le client App-V détecte la présence de la redirection de dossiers et copie les données sur le disque local pendant la publication et au démarrage de l'environnement virtuel. Une fois que l'utilisateur ferme l'application App-V et que le client App-V ferme l'environnement virtuel, le stockage local du répertoire AppData du système VFS est recopié sur le réseau, ce qui permet l'itinérance vers des ordinateurs supplémentaires, où le processus est répété. Les étapes détaillées des processus sont les suivantes :

1. Pendant la publication ou le démarrage de l'environnement virtuel, le client App-V détecte l'emplacement du répertoire AppData.

2. Si le chemin AppData itinérant est local ou que l'emplacement AppData\Roaming est mappé, rien ne se produit.

3. Si le chemin AppData itinérant n'est pas local, le répertoire AppData du système VFS est mappé sur le répertoire AppData local.

Ce processus résout le problème d'un répertoire %AppData% non local qui n'est pas pris en charge par le pilote VFS du client App-V. Toutefois, les données stockées dans ce nouvel emplacement ne sont pas itinérantes avec la redirection de dossiers. Toutes les modifications apportées pendant l'exécution de l'application se produisent à l'emplacement AppData local et doivent être copiées vers l'emplacement redirigé. Les étapes détaillées de ce processus sont les suivantes :

1. L'application App-V est arrêtée, ce qui arrête l'environnement virtuel.

2. Le cache local de l'emplacement AppData itinérant est compressé et stocké dans un fichier ZIP.

3. Un horodatage à la fin du processus d'empaquetage ZIP est utilisé pour nommer le fichier.

4. L'horodatage est inscrit dans le Registre : HKEY_CURRENT_USER\Software\Microsoft\AppV\Client\Packages\<GUID>\AppDataTime (dernier horodatage connu d'AppData).

5. Le processus de redirection de dossiers est appelé pour évaluer et lancer le fichier ZIP téléchargé dans le répertoire AppData itinérant.

L'horodatage est utilisé pour déterminer un scénario de type « le dernier enregistreur gagne » en cas de conflit et pour optimiser le téléchargement des données quand l'application App-V est publiée ou l'environnement virtuel démarré. La redirection de dossiers rend les données disponibles à partir de tous les autres clients concernés par la stratégie associée et permet de démarrer le processus de stockage des données AppData\Roaming à l'emplacement AppData local sur le client. Les processus détaillés sont les suivants :

1. L'utilisateur démarre l'environnement virtuel en démarrant une application.

2. L'environnement virtuel de l'application vérifie le fichier ZIP dont l'horodatage est le plus récent, s'il existe.

3. Le Registre est vérifié pour rechercher le dernier horodatage téléchargé connu, s'il existe.

4. Le fichier ZIP le plus récent est téléchargé, sauf si le dernier horodatage de téléchargement connu local est postérieur ou égal à l'horodatage du fichier ZIP.

5. Si le dernier horodatage de téléchargement connu local est antérieur à celui du fichier ZIP le plus récent à l'emplacement AppData itinérant, le fichier ZIP est extrait vers le répertoire temp local dans le profil de l'utilisateur.

6. Une fois le fichier ZIP correctement extrait, le cache local du répertoire AppData itinérant est renommé et les nouvelles données sont déplacées.

7. Le répertoire renommé est supprimé et l'application s'ouvre avec les dernières données AppData itinérantes enregistrées.

Cette étape termine l'itinérance correcte des paramètres d'application présents aux emplacements AppData\Roaming. La seule autre condition à traiter est celle d'une opération de réparation de package. Les détails du processus sont les suivants :

1. Pendant la réparation, détectez si le chemin vers le répertoire AppData itinérant de l'utilisateur n'est pas local.

2. Mappez le chemin AppData itinérant non local. Des cibles recréent les emplacements AppData local et itinérant attendus.

3. Supprimez l'horodatage stocké dans le Registre, le cas échéant.

Ce processus recrée à la fois des emplacements locaux et réseau pour AppData et supprime l'enregistrement de l'horodatage dans le Registre.

Gestion du cycle de vie des applications du client App-V

Dans une infrastructure complète App-V, une fois que les applications sont séquencées, elles sont gérées et publiées pour les utilisateurs ou ordinateurs via des serveurs d'administration App-V et de publication. Cette section détaille les opérations qui se produisent pendant les opérations courantes du cycle de vie des applications App-V (ajout, publication, lancement, mise à niveau et suppression) et les emplacements de fichiers et de Registre qui sont modifiés du point de vue du client App-V. Les opérations du client App-V sont exécutées sous la forme d'une série de commandes PowerShell sur l'ordinateur qui exécute le client App-V.

Ce document porte essentiellement sur les solutions de l'infrastructure complète App-V. Pour obtenir des informations spécifiques sur l'intégration d'App-V dans Configuration Manager 2012, visitez : https://go.microsoft.com/fwlink/?LinkId=392773.

Les tâches du cycle de vie des applications App-V sont déclenchées lors de la connexion de l'utilisateur (par défaut), du démarrage de l'ordinateur ou sous forme d'opérations minutées en arrière-plan. Les paramètres des opérations du client App-V, notamment les serveurs de publication, les intervalles d'actualisation, l'activation de scripts de package, sont configurés lors de l'installation du client ou après l'installation avec des commandes PowerShell. Consultez la section Comment déployer le client sur TechNet à l'adresse : Comment déployer le client App-V ou utilisez la commande PowerShell :

get-command *appv*

Actualisation de publication

Le processus d'actualisation de publication se compose de plusieurs opérations plus petites effectuées sur le client App-V. Étant donné qu'App-V est une technologie de virtualisation d'applications et non une technologie de planification de tâches, le Planificateur de tâches Windows est utilisé pour activer le processus lors de la connexion de l'utilisateur, du démarrage de l'ordinateur et à des intervalles planifiés. La configuration du client pendant l'installation répertoriée ci-dessus est la méthode recommandée pour distribuer le client à un grand groupe d'ordinateurs avec les bons paramètres. Ces paramètres client peuvent être configurés avec les applets de commande PowerShell suivantes :

• Add-AppVPublishingServer : configure le client avec un serveur de publication App-V qui fournit des packages App-V.

• Set-AppVPublishingServer : modifie les paramètres actuels du serveur de publication App-V.

• Set-AppVClientConfiguration : modifie les paramètres actuels du client App-V.

• Sync-AppVPublishingServer : lance manuellement un processus d'actualisation de publication App-V. Cette applet de commande est également utilisée dans les tâches planifiées créées lors de la configuration du serveur de publication.

Les sections suivantes visent à détailler les opérations qui se produisent lors des différentes phases d'une actualisation de publication App-V. Les rubriques incluent :

• Ajout d'un package App-V

• Publication d'un package App-V

Ajout d'un package App-V

L'ajout d'un package App-V au client est la première étape du processus d'actualisation de publication. Le résultat final est le même que celui de l'applet de commande Add-AppVClientPackage dans PowerShell, sauf que lors du processus d'ajout de l'actualisation de publication, le serveur de publication configuré est contacté et transmet une liste détaillée d'applications au client pour extraire des informations plus détaillées et non une opération d'ajout de package unique. Le processus continue avec la configuration du client pour les ajouts ou mises à jour de packages ou de groupes de connexion, puis l'accès au fichier appv. Ensuite, le contenu du fichier appv est développé et placé sur le système d'exploitation local aux emplacements appropriés. Voici le flux de travail détaillé du processus, en supposant que le package est configuré pour la diffusion en continu des erreurs.

Comment ajouter un package App-V

1. Lancement manuel via PowerShell ou lancement d'une séquence de tâches du processus d'actualisation de publication.

   1. Le client App-V établit une connexion HTTP et demande la liste des applications basées sur la cible. Le processus d'actualisation de publication prend en charge le ciblage des ordinateurs ou utilisateurs.

   2. Le serveur de publication App-V utilise l'identité de la cible, de l'utilisateur ou de l'ordinateur qui initialise, puis interroge la base de données pour obtenir la liste des applications autorisées. La liste des applications est fournie sous forme de réponse XML que le client utilise pour envoyer des demandes supplémentaires au serveur pour plus d'informations par package.

2. L'agent de publication sur le client App-V exécute toutes les actions ci-dessous sérialisées.

   Évaluer les groupes de connexion qui ne sont plus publiés ou qui sont désactivés, car les mises à jour de version de package qui font partie du groupe de connexion ne peuvent pas être traitées.

3. Configurer les packages en identifiant une opération d'ajout ou de mise à jour.

   1. Le client App-V utilise l'API AppX de Windows et accède au fichier appv à partir du serveur de publication.

   2. Le fichier de package est ouvert et les fichiers AppXManifest.xml et StreamMap.xml sont téléchargés vers le magasin de packages.

   3. Complètement diffuser en continue les données de bloc de publication définies dans le fichier StreamMap.xml. Stocker les données de bloc de publication à l'emplacement Package Store\PkgGUID\VerGUID\Root.

      • Icônes : cibles de points d'extension.

      • En-têtes exécutables portables (en-têtes PE) : cibles de points d'extension qui contiennent les informations de base sur les besoins d'image sur disque, directement accessibles ou via les types de fichiers.

      • Scripts : télécharger le répertoire de scripts pour l'utiliser tout au long du processus de publication.

   4. Remplir le magasin de packages :

      1. Créer des fichiers fragmentés sur le disque qui représentent le package extrait pour tous les répertoires indiqués.

      2. Effectuer une copie intermédiaire des fichiers et répertoires de niveau supérieur sous la racine.

      3. Tous les autres fichiers sont créés quand le répertoire est listé comme étant fragmenté sur le disque et diffusé en continu à la demande.

   5. Créer les entrées du catalogue de l'ordinateur. Créer les fichiers Manifest.xml et DeploymentConfiguration.xml à partir des fichiers de package (si aucun fichier DeploymentConfiguration.xml ne se trouve dans le package, un espace réservé est créé).

   6. Créer l'emplacement du magasin de packages dans le Registre HKLM\Software\Microsoft\AppV\Client\Packages\PkgGUID\Versions\VerGUID\Catalog

   7. Créer le fichier Registry.dat à partir du magasin de packages dans %ProgramData%\Microsoft\AppV\Client\VReg\{VersionGUID}.dat

   8. Enregistrer le package auprès du pilote en mode noyau App-V HKLM\Microsoft\Software\AppV\MAV

   9. Appeler le script à partir du fichier AppxManifest.xml ou DeploymentConfig.xml pour le minutage de l'ajout de packages.

4. Configurer des groupes de connexion en les ajoutant et en les activant ou en les désactivant.

5. Supprimer les objets qui ne sont pas publiés sur la cible (utilisateur ou ordinateur).

   Notes

   Cela ne supprime pas le package, mais plutôt les points d'intégration pour la cible spécifique (utilisateur ou ordinateur) et les fichiers du catalogue de l'utilisateur (du catalogue de l'ordinateur en cas de publication globale).

6. Appeler un montage de chargement en arrière-plan selon la configuration du client.

7. Les packages qui ont déjà des informations de publication pour l'ordinateur ou l'utilisateur sont immédiatement restaurés.

   Notes

   Cette condition survient suite à une suppression sans annulation de publication avec ajout en arrière-plan du package.

Ainsi se termine l'étape d'ajout d'un package App-V du processus d'actualisation de publication. L'étape suivante consiste à publier le package sur la cible spécifique (ordinateur ou utilisateur).

Publication d'un package App-V

Pendant l'opération d'actualisation de publication, l'opération de publication spécifique (Publish-AppVClientPackage) ajoute des entrées au catalogue de l'utilisateur, mappe les droits à l'utilisateur, identifie le magasin local et achève toutes les étapes d'intégration. Les étapes détaillées sont les suivantes.

Comment publier un package App-V

1. Les entrées de package sont ajoutées au catalogue de l'utilisateur

   1. Packages ciblés sur l'utilisateur : les fichiers UserDeploymentConfiguration.xml et UserManifest.xml sont placés sur l'ordinateur dans le catalogue de l'utilisateur

   2. Packages (globaux) ciblés sur l'ordinateur : le fichier UserDeploymentConfiguration.xml est placé dans le catalogue de l'ordinateur

2. Enregistrer le package auprès du pilote en mode noyau pour l'utilisateur dans HKLM\Software\Microsoft\AppV\MAV

3. Effectuer des tâches d'intégration.

   1. Créer des points d'extension.

   2. Stocker les informations de sauvegarde dans le Registre et le profil itinérant de l'utilisateur (sauvegardes de raccourcis).

      Notes

      Cette étape permet de restaurer des points d'extension si la publication du package est annulée.

   3. Exécuter des scripts ciblés pour la synchronisation de la publication.

La publication d'un package App-V qui fait partie d'un groupe de connexion est très similaire au processus ci-dessus. Pour les groupes de connexion, le chemin qui stocke les informations de catalogue spécifique inclut PackageGroups en tant qu'enfant du répertoire du catalogue. Consultez les informations sur les catalogues de l'ordinateur et de l'utilisateur ci-dessus pour plus d'informations.

Lancement d'application

Après le processus d'actualisation de publication, l'utilisateur lance et relance une application App-V. Le processus est très simple et optimisé pour un lancement rapide avec un minimum de trafic réseau. Le client App-V vérifie dans le chemin d'accès au catalogue de l'utilisateur si des fichiers ont été créés pendant la publication. Une fois que les droits pour lancer le package sont établis, le client App-V crée un environnement virtuel, commence la diffusion en continu de toutes les données nécessaires et applique les fichiers manifestes et de configuration du déploiement appropriés lors de la création de l'environnement virtuel. Avec l'environnement virtuel créé et configuré pour le package et l'application spécifiques, l'application démarre.

Comment lancer des applications App-V

1. L'utilisateur lance l'application en cliquant sur un appel de raccourci ou de type de fichier.

2. Le client App-V vérifie l'existence des fichiers suivants dans le catalogue de l'utilisateur :

   • UserDeploymentConfiguration.xml

   • UserManifest.xml

3. Si les fichiers sont présents, l'application est autorisée pour cet utilisateur spécifique et elle démarre le processus de lancement. Aucun trafic réseau n'a lieu à ce stade.

4. Ensuite, le client App-V vérifie que le chemin d'accès au package enregistré pour le service du client App-V existe dans le Registre.

5. Quand le chemin d'accès au magasin de packages est trouvé, l'environnement virtuel est créé. S'il s'agit du premier lancement, le bloc de fonctionnalité principal est téléchargé, le cas échéant.

6. Après le téléchargement, le service du client App-V consomme les fichiers manifestes et de configuration du déploiement pour configurer l'environnement virtuel et tous les sous-systèmes App-V sont chargés.

7. L'application est lancée. Pour les éventuels fichiers manquants dans le magasin de packages (fichiers fragmentés), App-V diffuse en continu les fichiers selon les besoins.

   

Mise à niveau d'un package App-V

Le processus de mise à niveau d'un package App-V 5 diffère des versions antérieures d'App-V. App-V prend en charge plusieurs versions du même package sur un ordinateur autorisé pour différents utilisateurs. Des versions de package peuvent être ajoutées à tout moment au fur et à mesure que le magasin de packages et les catalogues sont mis à jour avec de nouvelles ressources. Le seul processus spécifique à l'ajout de nouvelles ressources de version est l'optimisation du stockage. Pendant une mise à niveau, seuls les nouveaux fichiers sont ajoutés au nouvel emplacement de la banque des versions et des liens physiques sont créés pour les fichiers inchangés. Le stockage global est ainsi réduit en présentant uniquement le fichier à un seul emplacement de disque, puis en le projetant dans tous les dossiers avec une entrée d'emplacement de fichier sur le disque. Les détails spécifiques de la mise à niveau d'un package App-V sont les suivants :

Comment mettre à niveau un package App-V

1. Le client App-V effectue une actualisation de publication et découvre une version plus récente d'un package App-V.

2. Les entrées de package sont ajoutées au catalogue approprié pour la nouvelle version.

   1. Packages ciblés sur l'utilisateur : les fichiers UserDeploymentConfiguration.xml et UserManifest.xml sont placés sur l'ordinateur dans le catalogue de l'utilisateur à l'emplacement appdata\roaming\Microsoft\AppV\Client\Catalog\Packages\PkgGUID\VerGUID.

   2. Packages (globaux) ciblés sur l'ordinateur : le fichier UserDeploymentConfiguration.xml est placé dans le catalogue de l'ordinateur à l'emplacement %programdata%\Microsoft\AppV\Client\Catalog\Packages\PkgGUID\VerGUID.

3. Enregistrer le package auprès du pilote en mode noyau pour l'utilisateur dans HKLM\Software\Microsoft\AppV\MAV

4. Effectuer des tâches d'intégration.

   1. Intégrer des points d'extensions (EP) à partir des fichiers manifestes et de configuration dynamique.

   1. Les données des points d'extension basés sur les fichiers sont stockées dans le dossier AppData en utilisant des points de jonction dans le magasin de packages.

   2. Des points d'extension de version 1 existent déjà quand une nouvelle version est disponible.

   3. Les points d'extension basculent vers l'emplacement Version 2 dans les catalogues de l'ordinateur ou de l'utilisateur pour tous les points d'extension plus récents ou mis à jour.

5. Exécuter des scripts ciblés pour la synchronisation de la publication.

6. Installer les assemblys côte à côte en fonction des besoins.

Mise à niveau d'un package App-V en cours d'utilisation

À compter d'App-V 5 SP2 : Si vous essayez de mettre à niveau un package en cours d'utilisation par un utilisateur final, la tâche de mise à niveau est mise en attente. Elle s'exécute plus tard, selon les règles suivantes :

Type de tâche	Règle applicable
Tâche utilisateur, par exemple la publication d'un package vers un utilisateur	La tâche en attente est effectuée une fois que l'utilisateur se déconnecte, puis se reconnecte.
Tâche globale, par exemple l'activation d'un groupe de connexions de façon globale	La tâche en attente est effectuée quand l'ordinateur est arrêté, puis redémarré.

Quand une tâche est placée dans un état d'attente, le client App-V génère également une clé de Registre pour la tâche en attente, comme suit :

Tâche utilisateur ou globale	Emplacement de génération de la clé de Registre
Tâches utilisateur	KEY_CURRENT_USER\Software\Microsoft\AppV\Client\PendingTasks
Tâches globales	HKEY_LOCAL_MACHINE\Software\Microsoft\AppV\Client\PendingTasks

Les opérations suivantes doivent être effectuées au préalable pour que les utilisateurs puissent utiliser la version la plus récente du package :

Tâche	Détails
Ajouter le package à l'ordinateur	Cette tâche est propre à l'ordinateur et vous pouvez l'effectuer à tout moment en suivant les étapes décrites dans la section ci-dessus sur l'ajout d'un package.
Publier le package	Consultez la section sur la publication d'un package ci-dessus pour connaître les étapes. Ce processus requiert que vous mettiez à jour des points d'extension sur le système. Les utilisateurs finaux ne peuvent pas utiliser l'application pendant que vous effectuez cette tâche.

Utilisez les exemples de scénarios suivants comme des repères pour la mise à jour des packages.

Scénario	Conditions requises
Le package App-V n'est pas en cours d'utilisation quand vous essayez d'effectuer la mise à niveau.	Aucun des composants suivants du package ne peut être en cours d'utilisation : application virtuelle, serveur COM ou extensions d'environnement. L'administrateur publie une version plus récente du package et la mise à niveau fonctionne au lancement suivant d'un composant ou d'une application inclus dans le package. La nouvelle version du package est diffusée en continu et exécutée. Rien n'a changé dans ce scénario pour App-V 5 SP2 par rapport aux versions antérieures d'App-V 5.
Le package App-V est en cours d'utilisation quand l'administrateur publie une version plus récente du package.	L'opération de mise à niveau est mise en attente par le client App-V, ce qui signifie qu'elle est placée en file d'attente et exécutée plus tard quand le package n'est pas en cours d'utilisation. Si l'application du package est en cours d'utilisation, l'utilisateur ferme l'application virtuelle, après quoi la mise à niveau peut se produire. Si le package contient des extensions d'environnement (Office 2013), définitivement chargées par l'Explorateur Windows, l'utilisateur ne peut pas être connecté. Les utilisateurs doivent se déconnecter et se reconnecter pour lancer la mise à niveau du package App-V.

Publication globale ou sur un utilisateur

Il existe deux manières de publier des packages App-V : publication sur un utilisateur, qui autorise un package App-V pour un utilisateur ou groupe d'utilisateurs spécifiques et publication globale, qui autorise le package App-V pour tous les utilisateurs de l'ordinateur. Une fois qu'une mise à niveau de package a été ajoutée et que le package App-V n'est pas en cours d'utilisation, envisagez les deux types de publication :

• Publication globale : l'application est publiée sur un ordinateur ; tous les utilisateurs de cet ordinateur peuvent l'utiliser. La mise à niveau a lieu au démarrage du service du client App-V, ce qui implique effectivement un redémarrage de l'ordinateur.

• Publication sur un utilisateur : l'application est publiée sur un utilisateur. S'il existe plusieurs utilisateurs sur l'ordinateur, l'application peut être publiée sur un sous-ensemble d'utilisateurs. La mise à niveau se produit quand l'utilisateur se connecte ou lors d'une nouvelle publication (publication régulière, actualisation et évaluation de la stratégie ConfigMgr, actualisation/publication périodique d'App-V ou publication explicite via des commandes PowerShell).

Suppression d'un package App-V

La suppression d'applications App-V dans une infrastructure complète est une opération d'annulation de publication qui ne permet pas de supprimer un package. Le processus est le même que le processus de publication ci-dessus, mais au lieu d'ajouter, le processus de suppression annule les modifications qui ont été apportées aux packages App-V.

Réparation d'un package App-V

L'opération de réparation est très simple, mais elle peut affecter de nombreux emplacements sur l'ordinateur. Les emplacements de copie pour écriture précédemment mentionnés sont supprimés et des points d'extension sont désintégrés, puis réintégrés. Examinez les emplacements des données de copie pour écriture en recherchant où ils sont enregistrés dans le Registre. Cette opération est effectuée automatiquement et il n'existe aucun contrôle administratif autre que le lancement d'une opération de réparation à partir de la console du client App-V ou via PowerShell (Repair-AppVClientPackage).

Intégration de packages App-V

L'architecture du client App-V et des packages assure une intégration spécifique dans le système d'exploitation local lors de l'ajout et de la publication de packages. Trois fichiers définissent les points d'intégration ou d'extension d'un package App-V :

• AppXManifest.xml : stocké à l'intérieur du package avec des copies de secours stockées dans le magasin de packages et le profil de l'utilisateur. Contient les options créées pendant le processus de séquencement.

• DeploymentConfig.xml : fournit les informations de configuration des points d'extension de l'intégration en fonction de l'ordinateur et de l'utilisateur.

• UserConfig.xml : sous-ensemble du fichier Deploymentconfig.xml qui fournit uniquement des configurations utilisateur et qui cible uniquement des points d'extension utilisateur.

Règles d'intégration

Quand les applications App-V sont publiées sur un ordinateur avec le client App-V, certaines actions spécifiques sont exécutées comme décrit dans la liste ci-dessous :

• Publication globale : les raccourcis sont stockés à l'emplacement du profil Tous les utilisateurs et les autres points d'extension sont stockés dans le Registre dans la ruche HKLM.

• Publication sur un utilisateur : les raccourcis sont stockés dans le profil de compte d'utilisateur actuel et les autres points d'extension sont stockés dans le Registre dans la ruche HKCU.

• Sauvegarde et restauration : Les données d'applications natives existantes et le Registre (comme les enregistrements d'associations type-fichier) sont sauvegardées lors de la publication.

  1. Les packages App-V deviennent propriétaires en fonction du dernier package intégré pour lequel la propriété est transmise à l'application App-V la plus récemment publiée.

  2. La propriété se transfère à partir d'un package App-V vers un autre quand la publication du package App-V propriétaire est annulée. Ce transfert ne lance pas une restauration des données ni du Registre.

  3. Restaurez les données sauvegardées quand la publication du dernier package est annulée ou quand le package est supprimé par point d'extension.

Points d'extension

Les fichiers de publication App-V (manifeste et configuration dynamique) fournissent plusieurs points d'extension qui permettent à l'application de s'intégrer au système d'exploitation local. Ces points d'extension effectuent des tâches d'installation d'applications standard, comme le placement de raccourcis, la création d'associations type-fichier et l'inscription de composants. Comme il s'agit d'applications virtualisées qui ne sont pas installées de la même façon qu'une application traditionnelle, il existe des différences. Voici la liste des points d'extension abordés dans cette section :

• Raccourcis

• Associations de types de fichier

• Extensions d'environnement

• COM

• Clients logiciels

• Fonctionnalités d'application

• Gestionnaire de protocole URL

• AppPath

• Application virtuelle

Raccourcis

Le raccourci est l'un des éléments de base de l'intégration dans le système d'exploitation et il constitue l'interface pour le lancement direct par l'utilisateur d'une application App-V pendant la publication et l'annulation de la publication des applications App-V.

À partir des fichiers XML manifestes et de configuration dynamique d'un package, vous pouvez trouver le chemin d'accès à un exécutable d'application dans une section similaire à la suivante :

<Extension Category="AppV.Shortcut">
          <Shortcut>
            <File>[{Common Desktop}]\Adobe Reader 9.lnk</File>
            <Target>[{AppVPackageRoot}]\Reader\AcroRd32.exe</Target>
            <Icon>[{Windows}]\Installer\{AC76BA86-7AD7-1033-7B44-A94000000001}\SC_Reader.ico</Icon>
            <Arguments />
            <WorkingDirectory />
            <ShowCommand>1</ShowCommand>
            <ApplicationId>[{AppVPackageRoot}]\Reader\AcroRd32.exe</ApplicationId>
          </Shortcut>
        </Extension>

Comme mentionné précédemment, les raccourcis App-V sont placés par défaut dans le profil de l'utilisateur en fonction de l'opération d'actualisation. Une actualisation globale place les raccourcis dans le profil Tous les utilisateurs tandis qu'une actualisation de l'utilisateur les stocke dans le profil de l'utilisateur spécifique. L'exécutable réel est stocké dans le magasin de packages. L'emplacement du fichier ICO est un emplacement sous forme de jeton dans le package App-V.

Associations type-fichier

Le client App-V gère les associations type-fichier du système d'exploitation local pendant la publication, ce qui permet aux utilisateurs d'utiliser des appels de type de fichier ou d'ouvrir un fichier portant une extension spécialement enregistrée (.docx) pour démarrer une application App-V. Les associations type-fichier sont présentes dans les fichiers manifestes et de configuration dynamique, comme représenté dans l'exemple ci-dessous :

<Extension Category="AppV.FileTypeAssociation">
          <FileTypeAssociation>
            <FileExtension MimeAssociation="true">
              <Name>.xdp</Name>
              <ProgId>AcroExch.XDPDoc</ProgId>
              <ContentType>application/vnd.adobe.xdp+xml</ContentType>
            </FileExtension>
            <ProgId>
              <Name>AcroExch.XDPDoc</Name>
              <Description>Adobe Acrobat XML Data Package File</Description>
              <EditFlags>65536</EditFlags>
              <DefaultIcon>[{Windows}]\Installer\{AC76BA86-7AD7-1033-7B44-A94000000001}\XDPFile_8.ico</DefaultIcon>
              <ShellCommands>
                <DefaultCommand>Read</DefaultCommand>
                <ShellCommand>
                  <ApplicationId>[{AppVPackageRoot}]\Reader\AcroRd32.exe</ApplicationId>
                  <Name>Open</Name>
                  <CommandLine>"[{AppVPackageRoot}]\Reader\AcroRd32.exe" "%1"</CommandLine>
                </ShellCommand>
                <ShellCommand>
                  <ApplicationId>[{AppVPackageRoot}]\Reader\AcroRd32.exe</ApplicationId>
                  <Name>Printto</Name>
                  <CommandLine>"[{AppVPackageRoot}]\Reader\AcroRd32.exe"  /t "%1" "%2" "%3" "%4"</CommandLine>
                </ShellCommand>
                <ShellCommand>
                  <ApplicationId>[{AppVPackageRoot}]\Reader\AcroRd32.exe</ApplicationId>
                  <Name>Read</Name>
                  <FriendlyName>Open with Adobe Reader 9</FriendlyName>
                  <CommandLine>"[{AppVPackageRoot}]\Reader\AcroRd32.exe" "%1"</CommandLine>
                </ShellCommand>
              </ShellCommands>
            </ProgId>
          </FileTypeAssociation>
        </Extension>

Notes

Dans cet exemple :

• <Name>.xdp</Name> est l'extension ;
  
  
• <Name>AcroExch.XDPDoc</Name> est la valeur ProgId (qui pointe vers la valeur ProgId voisine) ;
  
  
• <CommandLine>"[{AppVPackageRoot}]\Reader\AcroRd32.exe" "%1"</CommandLine> est la ligne de commande, qui pointe vers l'exécutable de l'application.
  
  

Extensions d'environnement

Les extensions d'environnement sont automatiquement incorporées dans le package pendant le processus de séquencement. Quand le package est publié globalement, l'extension d'environnement offre aux utilisateurs la même fonctionnalité que si l'application était installée localement. L'application n'exige aucune installation ni configuration supplémentaire sur le client pour activer la fonctionnalité de l'extension d'environnement.

Conditions requises pour l'utilisation d'extensions d'environnement :

• Les packages qui contiennent des extensions d'environnement incorporées doivent être publiés globalement.

• Le nombre de bits de l'application, du séquenceur et du client App-V doit correspondre, sans quoi les extensions d'environnement ne fonctionnent pas. Par exemple :

  • La version de l'application est 64 bits.

  • Le séquenceur s'exécute sur un ordinateur 64 bits.

  • Le package est remis à un ordinateur client App-V 64 bits.

Le tableau suivant présente les extensions d'environnement prises en charge :

Gestionnaire	Description
Gestionnaire de menu contextuel	Ajoute des éléments de menu au menu contextuel. Appelé avant que le menu contextuel s'affiche.
Gestionnaire de glisser-déplacer	Contrôle l'action du clic droit, du glisser-déplacer et modifie le menu contextuel qui s'affiche.
Gestionnaire de cible de dépôt	Contrôle l'action une fois qu'un objet de données est déplacé et déposé sur une cible de dépôt telle qu'un fichier.
Gestionnaire d'objets de données	Contrôle l'action qui se produit après la copie d'un fichier dans le Presse-papiers ou son déplacement vers une cible de dépôt. Peut fournir des formats de Presse-papiers supplémentaires à la cible de dépôt.
Gestionnaire de feuille de propriétés	Remplace ou ajoute des pages à la boîte de dialogue de la feuille de propriétés d'un objet.
Gestionnaire d'info-bulle	Permet de récupérer des indicateurs et des informations d'info-bulle pour un élément, et de les afficher dans une info-bulle au passage de la souris.
Gestionnaire de colonnes	Permet de créer et d'afficher des colonnes personnalisées dans l'affichage Détails de l'Explorateur Windows. Peut être utilisé pour étendre le tri et le regroupement.
Gestionnaire d'aperçus	Permet d'afficher un aperçu d'un fichier dans le volet de visualisation de l'Explorateur Windows.

COM

Le client App-V prend en charge la publication d'applications avec prise en charge de l'intégration COM et de la virtualisation. L'intégration COM permet au client App-V d'inscrire des objets COM sur le système d'exploitation local et de virtualiser des objets. Dans le cadre de ce document, l'intégration des objets COM requiert des détails supplémentaires.

App-V prend en charge l'enregistrement d'objets COM depuis le package vers le système d'exploitation local avec deux types de processus : out-of-process et in-process. L'enregistrement d'objets COM est effectué avec un ou plusieurs modes de fonctionnement pour un package App-V spécifique, notamment les modes désactivé, isolé et intégré. Le mode intégré est configuré pour le type out-of-process ou le type in-process. La configuration des modes et types COM est effectuée avec les fichiers de configuration dynamique (deploymentconfig.xml ou userconfig.xml).

Des informations supplémentaires sur l'intégration d'App-V sont disponibles ici : https://go.microsoft.com/fwlink/?LinkId=392834.

Clients logiciels et fonctionnalités d'application

App-V prend en charge des points d'extension de clients logiciels et de fonctionnalités d'application spécifiques qui permettent aux applications virtualisées de s'enregistrer auprès du client logiciel du système d'exploitation. Cela permet aux utilisateurs de sélectionner des programmes par défaut pour des opérations comme le courrier électronique, la messagerie instantanée et la lecture multimédia. Cette opération s'effectue dans le Panneau de configuration Définition des paramètres par défaut de l'accès aux programmes et de l'ordinateur et elle est configurée pendant le séquencement dans les fichiers manifestes ou de configuration dynamique. Les fonctionnalités d'application sont uniquement prises en charge quand les applications App-V sont publiées globalement.

Exemple d'enregistrement du client logiciel d'un client de messagerie App-V.

    <SoftwareClients Enabled="true">
      <ClientConfiguration EmailEnabled="true" />
      <Extensions>
        <Extension Category="AppV.SoftwareClient">
          <SoftwareClients>
            <EMail MakeDefault="true">
              <Name>Mozilla Thunderbird</Name>
              <Description>Mozilla Thunderbird</Description>
              <DefaultIcon>[{ProgramFilesX86}]\Mozilla Thunderbird\thunderbird.exe,0</DefaultIcon>
              <InstallationInformation>
                <RegistrationCommands>
                  <Reinstall>"[{ProgramFilesX86}]\Mozilla Thunderbird\uninstall\helper.exe" /SetAsDefaultAppGlobal</Reinstall>
                  <HideIcons>"[{ProgramFilesX86}]\Mozilla Thunderbird\uninstall\helper.exe" /HideShortcuts</HideIcons>
                  <ShowIcons>"[{ProgramFilesX86}]\Mozilla Thunderbird\uninstall\helper.exe" /ShowShortcuts</ShowIcons>
                </RegistrationCommands>
                <IconsVisible>1</IconsVisible>
                <OEMSettings />
              </InstallationInformation>
              <ShellCommands>
                <ApplicationId>[{ProgramFilesX86}]\Mozilla Thunderbird\thunderbird.exe</ApplicationId>
                <Open>"[{ProgramFilesX86}]\Mozilla Thunderbird\thunderbird.exe" -mail</Open>
              </ShellCommands>
              <MAPILibrary>[{ProgramFilesX86}]\Mozilla Thunderbird\mozMapi32_InUse.dll</MAPILibrary>
              <MailToProtocol>
                <Description>Thunderbird URL</Description>
                <EditFlags>2</EditFlags>
                <DefaultIcon>[{ProgramFilesX86}]\Mozilla Thunderbird\thunderbird.exe,0</DefaultIcon>
                <ShellCommands>
                  <ApplicationId>[{ProgramFilesX86}]\Mozilla Thunderbird\thunderbird.exe</ApplicationId>
                  <Open>"[{ProgramFilesX86}]\Mozilla Thunderbird\thunderbird.exe" -osint -compose "%1"</Open>
                </ShellCommands>
              </MailToProtocol>
            </EMail>
          </SoftwareClients>
        </Extension>
      </Extensions>
    </SoftwareClients>

Notes

Dans cet exemple :

• <ClientConfiguration EmailEnabled="true" /> correspond au paramètre général des clients logiciels pour intégrer les clients de messagerie.
  
  
• <EMail MakeDefault="true"> est l'indicateur permettant de définir un client de messagerie particulier en tant que client de messagerie par défaut.
  
  
• <MAPILibrary>[{ProgramFilesX86}]\Mozilla Thunderbird\mozMapi32_InUse.dll</MAPILibrary> est l'enregistrement dll MAPI.
  
  

Gestionnaire de protocole URL

Les applications n'appellent pas toujours spécifiquement les applications virtualisées par un appel de type de fichier. Par exemple, dans une application qui prend en charge l'incorporation d'un lien mailto: dans un document ou une page web, l'utilisateur clique sur un lien mailto: et s'attend à obtenir son client de messagerie enregistré. App-V prend en charge les gestionnaires de protocole URL pouvant être enregistrés par package auprès du système d'exploitation local. Pendant le séquencement, les gestionnaires de protocole URL sont automatiquement ajoutés au package.

Pour les situations où il existe plusieurs applications qui peuvent enregistrer le gestionnaire de protocole URL spécifique, les fichiers de configuration dynamique peuvent être utilisés pour modifier le comportement et supprimer ou désactiver cette fonctionnalité pour une application qui ne doit pas être la principale application lancée.

AppPath

Le point d'extension AppPath prend en charge l'appel des applications App-V directement depuis le système d'exploitation. Un tel appel s'effectue généralement à partir de l'écran Exécuter ou de l'écran de démarrage, selon le système d'exploitation, ce qui permet aux administrateurs de fournir l'accès aux applications App-V à partir de commandes ou de scripts du système d'exploitation sans appeler le chemin d'accès spécifique de l'exécutable. Par conséquent, toute modification de la variable d'environnement du chemin système est évitée sur tous les systèmes, puisqu'elle s'effectue pendant la publication.

Le point d'extension AppPath est configuré soit dans les fichiers manifestes, soit dans les fichiers de configuration dynamique. Il est stocké dans le Registre sur l'ordinateur local pendant la publication pour l'utilisateur. Pour plus d'informations sur AppPath, consultez : https://go.microsoft.com/fwlink/?LinkId=392835.

Application virtuelle

Ce sous-système fournit la liste des applications capturées pendant le séquencement, laquelle est généralement utilisée par d'autres composants App-V. L'intégration des points d'extension appartenant à une application particulière peut être désactivée à l'aide de fichiers de configuration dynamique. Par exemple, si un package contient deux applications, il est possible de désactiver tous les points d'extension appartenant à une application, afin d'autoriser uniquement l'intégration des points d'extension de l'autre application.

Règles des points d'extension

Les points d'extension décrits ci-dessus sont intégrés au système d'exploitation selon la façon dont les packages ont été publiés. Une publication globale place les points d'extension à des emplacements d'ordinateur publics, tandis qu'une publication sur un utilisateur les place à des emplacements d'utilisateur. Par exemple, un raccourci créé sur le Bureau et publié globalement engendre les données fichier pour le raccourci (%Public%\Desktop) et les données du Registre (HKLM\Software\Classes). Le même raccourci aurait des données fichier (%UserProfile%\Desktop) et des données du Registre (HKCU\Software\Classes).

Les points d'extension ne sont pas tous publiés de la même façon. Tandis que certains points d'extension requièrent une publication globale, d'autres requièrent un séquencement sur le système d'exploitation et l'architecture spécifiques dans lesquels ils sont remis. Voici un tableau qui décrit ces deux principales règles.

Extension virtuelle	Requiert le séquencement du système d'exploitation cible.	Requiert une publication globale.
Shortcut
Associations type-fichier
Protocoles URL	X
AppPaths	X
Mode COM
Clients logiciels	X
Fonctionnalités d'application	X	X
Gestionnaire de menu contextuel	X	X
Gestionnaire de glisser-déplacer	X
Gestionnaire d'objets de données	X
Gestionnaire de feuille de propriétés	X
Gestionnaire d'info-bulle	X
Gestionnaire de colonnes	X
Extensions d'environnement	X
Objet application d'assistance du navigateur	X	X
Objet ActiveX	X	X

Traitement de la configuration dynamique

Le déploiement de packages App-V sur un seul ordinateur ou utilisateur est très simple. Toutefois, à mesure que les organisations déploient des applications AppV au-delà de leurs lignes métier et limites géographiques et politiques, il devient impossible de séquencer une application une seule fois avec un seul ensemble de paramètres. App-V a été conçu pour ce scénario, car il capture les paramètres et configurations spécifiques pendant le séquencement dans le fichier manifeste, mais prend également en charge les modifications avec des fichiers de configuration dynamique.

La configuration dynamique App-V permet de spécifier une stratégie pour un package au niveau de l'ordinateur ou au niveau de l'utilisateur. Les fichiers de configuration dynamique permettent aux ingénieurs de séquencement de modifier la configuration d'un package, après le séquencement, pour répondre aux besoins des groupes individuels d'utilisateurs ou d'ordinateurs. Dans certains cas, il peut être nécessaire d'apporter des modifications à l'application pour fournir les fonctionnalités appropriées dans l'environnement App-V. Par exemple, il peut s'avérer nécessaire d'apporter des modifications aux fichiers _*config.xml pour autoriser l'exécution de certaines actions à une heure spécifiée pendant l'exécution de l'application, comme la désactivation d'une extension mailto pour empêcher une application virtualisée de remplacer cette extension à partir d'une autre application.

Les packages App-V incluent le fichier manifeste dans le fichier de package appv, lequel est représentatif des opérations de séquencement et constitue la stratégie de choix, sauf si des fichiers de configuration dynamique sont affectés à un package spécifique. Après le séquencement, les fichiers de configuration dynamique peuvent être modifiés pour autoriser la publication d'une application sur différents ordinateurs de bureau ou utilisateurs avec des points d'extension différents. Les deux fichiers de configuration dynamique sont le fichier de configuration du déploiement dynamique (DDC) et le fichier de configuration utilisateur dynamique (DUC). Cette section se concentre sur la combinaison des fichiers manifestes et de configuration dynamique.

Exemple de fichiers de configuration dynamique

L'exemple ci-dessous illustre la combinaison des fichiers manifestes, de configuration du déploiement et de configuration utilisateur après la publication et en situation de fonctionnement normal. Ces exemples sont des exemples abrégés de chacun des fichiers. L'objectif est uniquement de montrer la combinaison des fichiers et non de décrire de manière exhaustive les catégories spécifiques disponibles dans chacun des fichiers. Pour plus d'informations, consultez le guide sur le séquencement d'App-V 5 à l'adresse : https://go.microsoft.com/fwlink/?LinkID=269810

Manifeste

<appv:Extension Category="AppV.Shortcut">
     <appv:Shortcut>
          <appv:File>[{Common Programs}]\7-Zip\7-Zip File Manager.lnk</appv:File>
          <appv:Target>[{AppVPackageRoot}]\7zFM.exe</appv:Target>
          <appv:Icon>[{AppVPackageRoot}]\7zFM exe.O.ico</appv:Icon>
     </appv:Shortcut>
</appv:Extension>

Configuration du déploiement

<MachineConfiguration>
     <Subsystems>
          <Registry>
               <Include>
                    <Key Path= "\REGISTRY\Machine\Software\7zip">
                    <Value Type="REG_SZ" Name="Config" Data="1234"/>
                    </Key>
               </Include>
          </Registry>
     </Subsystems>

Configuration utilisateur

<UserConfiguration>
     <Subsystems>
<appv:ExtensionCategory="AppV.Shortcut">
     <appv:Shortcut>
          <appv:File>[{Desktop}]\7-Zip\7-Zip File Manager.lnk</appv:File>
          <appv:Target>[{AppVPackageRoot}]\7zFM.exe</appv:Target>
          <appv:Icon>[{AppVPackageRoot}]\7zFM exe.O.ico</appv:Icon>
     </appv:Shortcut>
</appv:Extension>
     </Subsystems>
<UserConfiguration>
     <Subsystems>
<appv:Extension Category="AppV.Shortcut">
     <appv:Shortcut>
          <appv:Fìle>[{Desktop}]\7-Zip\7-Zip File Manager.lnk</appv:File>
          <appv:Target>[{AppVPackageRoot}]\7zFM.exe</appv:Target>
          <appv:lcon>[{AppVPackageRoot}]\7zFM.exe.O.ico</appv:Icon>
     </appv:Shortcut>
     <appv:Shortcut>
          <appv:File>[{Common Programs}]\7-Zip\7-Zip File Manager.Ink</appv:File>
          <appv:Target>[{AppVPackageRoot}]\7zFM.exe</appv:Target>
          <appv:lcon>[{AppVPackageRoot)]\7zFM.exe.O.ico</appv: Icon>
     </appv:Shortcut>
</appv:Extension>
     </Subsystems>
<MachineConfiguration>
     <Subsystems>
          <Registry>
               <Include>
                    <Key Path="\REGISTRY\Machine\Software\7zip">
                    <Value Type=”REG_SZ" Name="Config" Data="1234"/>
               </Include>
          </Registry>
     </Subsystems>

Assemblys côte à côte

App-V prend en charge l'empaquetage automatique des assemblys côte à côte pendant le séquencement et le déploiement sur le client lors de la publication d'une application virtuelle. App-V 5 SP2 prend en charge la capture des assemblys côte à côte pendant le séquencement des assemblys absents de l'ordinateur de séquencement. De plus, pour les assemblys constitués d'un runtime Visual C++ (version 8 et ultérieures) et/ou MSXML, Sequencer détecte et capture automatiquement ces dépendances, même si elles n'ont pas été installées pendant l'analyse. La fonctionnalité des assemblys côte à côte supprime les limites des versions antérieures d'App-V, dans lesquelles App-V Sequencer ne capturait pas les assemblys déjà présents sur la station de travail de séquencement et privatisait les assemblys, ce qui les limitait à une version d'un seul bit par package. Ce comportement avait pour conséquence des échecs de lancement des applications en raison d'assemblys côte à côte requis manquants dans les applications App-V déployées sur les clients. Il forçait le processus d'empaquetage à une documentation pour garantir l'installation locale de tous les assemblys requis pour les packages sur le système d'exploitation client de l'utilisateur afin d'assurer la prise en charge des applications virtuelles. Selon le nombre d'assemblys et le manque de documentation d'application pour les dépendances requises, cette tâche était difficile à la fois du point de vue de sa gestion et de son implémentation.

La prise en charge des assemblys côte à côte dans App-V propose les fonctionnalités suivantes.

• Captures automatiques de l'assembly côte à côte pendant le séquencement, que l'assembly soit déjà installé sur la station de travail de séquencement ou non.

• Le client App-V installe automatiquement les assemblys côte à côte requis sur l'ordinateur client au moment de la publication quand ils sont absents.

• Le séquenceur signale la dépendance d'exécution VC dans son mécanisme de création de rapports.

• Sequencer permet de choisir de ne pas empaqueter les assemblys déjà installés sur Sequencer, en prenant en charge les scénarios où les assemblys ont été précédemment installés sur les ordinateurs cibles.

Publication automatique des assemblys côte à côte

Lors de la publication d'un package App-V avec des assemblys côte à côte, le client App-V vérifie la présence de l'assembly sur l'ordinateur. Si l'assembly n'existe pas, le client le déploie sur l'ordinateur. Les packages qui font partie de groupes de connexion reposent sur les installations d'assemblys côte à côte qui font partie des packages de base, puisque les groupes de connexion ne contiennent pas d'informations sur l'installation des assemblys.

Notes

L'annulation de la publication d'un package ou sa suppression avec un assembly ne supprime pas les assemblys pour ce package.

Journalisation des clients

Les clients App-V enregistrent des informations dans le journal des événements Windows au format ETW standard. Les événements App-V spécifiques figurent dans l'observateur d'événements, sous Journaux des applications et des services \Microsoft\AppV\Client.

Notes

Dans App-V 5.0 SP3, certains journaux ont été regroupés et déplacés vers l'emplacement suivant :

Event logs/Applications and Services Logs/Microsoft/AppV/ServiceLog

Pour obtenir la liste des journaux déplacés, consultez App-V event logs have been consolidated.

Il existe trois catégories spécifiques d'événements enregistrés, décrites ci-dessous.

Administrateur : Enregistre les événements pour les configurations appliquées au client App-V et contient les principaux avertissements et erreurs.

Opérationnel : Enregistre l'exécution App-V générale et l'utilisation des composants individuels, ce qui crée un journal d'audit des opérations App-V qui ont été effectuées sur le client App-V.

Application virtuelle : Enregistre les lancements d'applications virtuelles et l'utilisation des sous-systèmes de virtualisation.

Vous avez une suggestion pour App-V ?

Ajoutez des suggestions ou votez pour les meilleures ici. Pour les problèmes relatifs à App-V, utilisez le Forum TechNet App-V.

-----
Vous pouvez en apprendre plus sur MDOP dans Bibliothèque TechNet, rechercher des solutions à des problèmes dans le TechNet Wiki ou nous suivre sur Facebook ou Twitter.
-----