Informations de référence sur la publication d’applications et l’interaction client

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.

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

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

Sequencer crée des packages App-V et produit une application virtualisée. Le processus de séquencement crée les fichiers suivants :

Fichier	Description
.appv	- Le fichier de package principal, qui contient les ressources capturées et les informations d’état du processus de séquencement. - Architecture du fichier de package, des informations de publication et du registre sous une forme tokenisée qui peut être réappliquée à un ordinateur et à un utilisateur spécifique lors de la remise.
.MSI	Wrapper de déploiement exécutable que vous pouvez utiliser pour déployer .appv des fichiers manuellement ou à l’aide d’une plateforme de déploiement non-Microsoft.
_DeploymentConfig.XML	Fichier utilisé pour personnaliser les paramètres de publication par défaut pour toutes les applications d’un package déployé globalement sur 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 dans un package déployé sur 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 pilotes, fichiers et emplacements de Registre omis.
.CAB	Optionnel: Fichier accélérateur de package utilisé pour reconstruire automatiquement un package d’application virtuelle précédemment séquencé.
.appvt	Optionnel: Fichier de modèle Sequencer utilisé pour conserver les paramètres sequencer couramment réutilisés.

Qu’y a-t-il dans le appv fichier ?

Le appv fichier 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, qui est basé sur la norme OPC (Open Packaging Conventions).

Pour afficher le contenu du appv fichier, effectuez une copie du package, puis renommez le fichier copié en extension ZIP.

Le appv fichier contient le dossier et les fichiers suivants, qui sont utilisés lors de la création et de la publication d’une application virtuelle :

Nom	Type	Description
Root	Dossier de fichiers	Répertoire qui contient le système de fichiers de l’application virtualisée capturé pendant le séquencement.
[Content_Types].xml	Fichier XML	Liste des principaux types de contenu dans le appv fichier (par exemple DLL, EXE, BIN).
AppxBlockMap.xml	Fichier XML	Disposition du appv fichier, qui utilise les éléments File, Block et BlockMap qui permettent l’emplacement et la validation des fichiers dans le package App-V.
AppxManifest.xml	Fichier XML	Métadonnées du package qui contient les informations requises pour l’ajout, la publication et le lancement du package. Inclut des points d’extension (associations de types de fichiers et raccourcis) et 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 pour le bloc de fonctionnalité principal et de publication. Le bloc de fonctionnalités 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és 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 effectue des tâches pour s’assurer que les applications virtuelles s’exécutent correctement et fonctionnent comme des applications installées localement. Le processus d’ouverture et d’exécution d’applications virtuelles nécessite un mappage à partir du système de fichiers et du registre virtuels pour garantir que l’application dispose des composants requis d’une application traditionnelle attendue par les utilisateurs. Cette section décrit les ressources requises pour exécuter des applications virtuelles et répertorie l’emplacement où App-V stocke les ressources.

Nom	Emplacement	Description
Magasin de packages	%ProgramData%\App-V	Emplacement par défaut des fichiers de package en lecture seule
Catalogue de machines	%ProgramData%\Microsoft\AppV\Client\Catalog	Contient des documents de configuration par machine
Catalogue de l’utilisateur	%AppData%\Microsoft\AppV\Client\Catalog	Contient des documents de configuration par utilisateur
Raccourcir les sauvegardes	%AppData%\Microsoft\AppV\Client\Integration\ShortCutBackups	Stocke les points d’intégration précédents qui activent la restauration lors de l’annulation de la publication du package
Copy on Write (COW) Roaming	%AppData%\Microsoft\AppV\Client\VFS	Emplacement itinérant accessible en écriture pour la modification du package
Copier sur écriture (COW) local	%LocalAppData%\Microsoft\AppV\Client\VFS	Emplacement non itinérant accessible en écriture pour la modification du package
Registre d’ordinateurs	HKLM\Software\Microsoft\AppV	Contient des informations sur l’état du package, notamment VReg pour l’ordinateur ou les packages publiés globalement (Ruche de machine)
Registre des utilisateurs	HKCU\Software\Microsoft\AppV	Contient des informations sur l’état du package utilisateur, y compris VReg
Classes de Registre utilisateur	HKCU\Software\Classes\AppV	Contient des informations supplémentaires sur l’état du package utilisateur

Pour plus d’informations sur le tableau, consultez les sections suivantes.

Magasin de packages

Le client App-V gère les ressources d’applications montées 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 Set-AppVClientConfiguration commande PowerShell, qui modifie le Registre local (PackageInstallationRoot valeur sous la HKLM\Software\Microsoft\AppV\Client\Streaming clé). 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 pour le GUID du package et le GUID de 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 lorsqu’une erreur de flux se produit, ce qui signifie que les packages nécessitent un espace disque local minimal (publication des données). L’utilisation de moins d’espace disque est fortement souhaitable dans les environnements VDI, où le stockage local peut être limité, et la diffusion en continu des applications à partir d’un emplacement réseau hautes performances (tel qu’un RÉSEAU SAN) est préférable.

Remarque

La machine et le magasin de packages doivent se trouver sur un lecteur local, même lorsque vous utilisez des configurations du magasin de contenu partagé pour le client App-V.

Catalogues de packages

Le client App-V gère les deux emplacements basés sur les fichiers suivants :

• Catalogues (utilisateur et ordinateur).

• Emplacements du Registre : dépend de la façon dont le package est ciblé pour la publication. Il existe un catalogue (magasin de données) pour l’ordinateur et un catalogue pour chaque utilisateur individuel. Le catalogue d’ordinateurs stocke des informations globales applicables à tous les utilisateurs ou à n’importe quel utilisateur, et le catalogue utilisateur stocke les informations applicables à un utilisateur spécifique. Le catalogue est une collection de configurations dynamiques et de fichiers manifestes ; il existe des données discrètes pour le fichier et le registre par version de package.

Catalogue de machines

Description du catalogue de machines

Stocke les documents de package qui sont disponibles pour les utilisateurs sur l’ordinateur, lorsque les 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 toujours des ressources globales qui sont modifiées et visibles par tout le monde sur l’ordinateur client. Par exemple, le répertoire du package se trouve dans un emplacement de disque partagé.

Si un package global ou non global est disponible pour un utilisateur sur l’ordinateur, le manifeste est stocké dans le catalogue de machines. Lorsqu’un package est publié globalement, un fichier de configuration dynamique est stocké dans le catalogue de machines. La détermination de la valeur globale d’un package est définie en fonction de la présence ou non d’un fichier de stratégie UserDeploymentConfiguration dans le catalogue de machines.

Emplacement de stockage par défaut du catalogue d’ordinateurs

%programdata%\Microsoft\AppV\Client\Catalog

Cet emplacement n’est pas identique à l’emplacement du magasin de packages. Le magasin de packages est la copie dorée ou vierge des fichiers de package.

Fichiers dans le catalogue d’ordinateurs

• Manifest.xml
• DeploymentConfiguration.xml
• UserManifest.xml (package globalement publié)
• UserDeploymentConfiguration.xml (package globalement publié)

Autre emplacement du catalogue de machines, utilisé lorsque le package fait partie d’un groupe de connexions

L’emplacement suivant s’ajoute à l’emplacement du package principal spécifique :

%programdata%\Microsoft\AppV\Client\Catalog\PackageGroups\ConGroupGUID\ConGroupVerGUID

Autres fichiers dans le catalogue d’ordinateurs lorsque le package fait partie d’un groupe de connexions

• PackageGroupDescriptor.xml
• UserPackageGroupDescriptor.xml (groupe de connexions publié à l’échelle mondiale)

Catalogue utilisateur

Description du catalogue utilisateur

Créé pendant le processus de publication. Contient des informations utilisées pour la publication du package et également utilisées au lancement pour garantir qu’un package est approvisionné pour un utilisateur spécifique. Créé dans un emplacement itinérant et inclut des informations de publication spécifiques à l’utilisateur.

Lorsqu’un package est publié pour un utilisateur, le fichier de stratégie est stocké dans le catalogue utilisateur. En même temps, une copie du manifeste est également stockée dans le catalogue utilisateur. Lorsqu’un droit de package est supprimé pour un utilisateur, les fichiers de package appropriés sont supprimés du catalogue d’utilisateurs. En examinant le catalogue d’utilisateurs, un administrateur peut voir la présence d’un fichier de configuration dynamique, ce qui indique que le package est autorisé pour cet utilisateur.

Pour les utilisateurs itinérants, le catalogue d’utilisateurs doit se trouver dans un emplacement itinérant ou partagé pour conserver le comportement App-V hérité du ciblage des utilisateurs par défaut. Les droits d’utilisation et la stratégie sont liés à un utilisateur, et non à un ordinateur, ils doivent donc être itinérants avec l’utilisateur une fois qu’ils sont approvisionnés.

Emplacement de stockage par défaut du catalogue utilisateur

appdata\roaming\Microsoft\AppV\Client\Catalog\Packages\PkgGUID\VerGUID

Fichiers dans le catalogue utilisateur

• UserManifest.xml
• DynamicConfiguration.xml ou UserDeploymentConfiguration.xml

Autre emplacement du catalogue d’utilisateurs, utilisé lorsque le package fait partie d’un groupe de connexions

L’emplacement suivant s’ajoute à l’emplacement du package principal spécifique :

appdata\roaming\Microsoft\AppV\Client\Catalog\PackageGroups\PkgGroupGUID\PkgGroupVerGUID

Un autre fichier dans le catalogue d’ordinateurs lorsque le package fait partie d’un groupe de connexions

UserPackageGroupDescriptor.xml

Sauvegardes de raccourcis

Pendant le processus de publication, le client App-V sauvegarde tous les raccourcis et points d’intégration vers %AppData%\Microsoft\AppV\Client\Integration\ShortCutBackups. Cette sauvegarde permet la restauration de ces points d’intégration vers les versions précédentes lorsque le package n’est pas publié.

Copier lors de l’écriture de fichiers

Le magasin de packages contient une copie vierge des fichiers de package qui ont été diffusés en continu à partir du serveur de publication. Pendant le fonctionnement normal d’une application App-V, l’utilisateur ou le service peut nécessiter des modifications des fichiers. Ces modifications ne sont pas apportées dans le magasin de packages afin de préserver votre capacité à réparer l’application, ce qui supprime ces modifications. Ces emplacements sont appelés « copy on write » (COW), qui prend en charge les emplacements itinérants et non itinérants. L’emplacement où les modifications sont stockées dépend de l’emplacement où l’application écrit les modifications en mode natif.

Itinérance COW

L’emplacement COW Roaming décrit ci-dessus stocke les modifications apportées aux fichiers et répertoires qui ciblent l’emplacement %AppData% classique ou \Users\{username}\AppData\Roaming location. Ces répertoires et fichiers sont ensuite itinérants en fonction des paramètres du système d’exploitation.

VACHE LOCALE

L’emplacement cow local est similaire à l’emplacement itinérant, mais les répertoires et les fichiers ne sont pas itinérants vers d’autres ordinateurs, même si la prise en charge de l’itinérance est configurée. L’emplacement local COW décrit ci-dessus stocke les modifications applicables aux fenêtres classiques, et non à l’emplacement %AppData%. Les répertoires répertoriés varient, mais il existe deux emplacements pour tous les emplacements Windows classiques. Par exemple, AppData commun et AppDataS commun. S signifie l’emplacement restreint lorsque le service virtuel demande la modification en tant qu’utilisateur avec élévation de privilèges différent de celui des utilisateurs connectés. L’emplacement non-S stocke les modifications basées sur l’utilisateur.

Registre de packages

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

Lorsqu’un nouveau package est ajouté au client App-V, copie du REGISTRE. Le fichier DAT du package est créé à l’adresse %ProgramData%\Microsoft\AppV\Client\VREG\{Version GUID}.dat. Le nom du fichier est le GUID de version avec . Extension DAT. La raison pour laquelle cette copie est effectuée est de s’assurer que le fichier hive réel dans le package n’est jamais en cours d’utilisation, ce qui empêcherait la suppression du package ultérieurement.

Registry.dat à partir du magasin> de packages%ProgramData%\Microsoft\AppV\Client\Vreg{VersionGuid}.dat

Lorsque la première application du package est lancée sur le client, le client met en scène ou copie le contenu du fichier hive, en recréant les données du registre de package dans un autre emplacement HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AppV\Client\Packages\PackageGuid\Versions\VersionGuid\REGISTRY. Les données de Registre intermédiaires ont deux types distincts de données machine et de données utilisateur. Les données de l’ordinateur sont partagées entre tous les utilisateurs de l’ordinateur. Les données utilisateur sont intermédiaires pour chaque utilisateur vers un emplacement HKCU\Software\Microsoft\AppV\Client\Packages\PackageGuid\Registry\Userspécifique à l’utilisateur. Les données de l’ordinateur sont finalement supprimées au moment de la suppression du package, et les données utilisateur sont supprimées lors d’une opération d’annulation de publication de l’utilisateur.

Mise en lots du registre de package et mise en lots du registre du groupe de connexions

Lorsque des groupes de connexions sont présents, le processus précédent de mise en lots du Registre est vrai, mais au lieu d’avoir un fichier hive à traiter, il en existe plusieurs. Les fichiers sont traités dans l’ordre dans lequel ils apparaissent dans le groupe de connexions XML, le premier enregistreur gagnant les conflits.

Le registre intermédiaire est conservé de la même façon que dans le cas de package unique. Les données du registre des utilisateurs intermédiaires restent pour le groupe de connexions jusqu’à ce qu’elles soient désactivées. Les données du registre des ordinateurs intermédiaires sont supprimées lors de la suppression du groupe de connexions.

Registre virtuel

L’objectif du registre virtuel (VREG) est de fournir une vue fusionnée unique du registre de packages et du registre natif aux applications. Il fournit également la fonctionnalité de copie sur écriture (COW), c’est-à-dire que toutes les modifications apportées au Registre à partir du contexte d’un processus virtuel sont apportées à un emplacement COW distinct. Cela signifie que le VREG doit combiner jusqu’à trois emplacements de registre distincts dans une seule vue en fonction des emplacements remplis dans le registre COW - package ->> natif. Lorsqu’une demande de données de registre est effectuée, il localise dans l’ordre jusqu’à ce qu’il trouve les données qu’il demandait. Si une valeur est stockée dans un emplacement COW, elle ne passe pas à d’autres emplacements. S’il n’y a pas de données dans l’emplacement COW, il passe au package, puis à l’emplacement natif jusqu’à ce qu’il trouve les données appropriées.

Emplacements du registre

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

VReg à package unique

Emplacement	Description
VACHE	- Machine Registry\Client\Packages\PkgGUID\REGISTRY (seul le processus d’élévation de privilèges peut écrire) - User Registry\Client\Packages\PkgGUID\REGISTRY (User Roaming anything written under HKCU except Software\Classes) - User Registry Classes\Client\Packages\PkgGUID\REGISTRY (HKCU\Software\Classes writes et HKLM pour les processus sans élévation de privilèges)
Package	- Registre de machines\Client\Packages\PkgGUID\Versions\VerGuid\Registry\Machine - User Registry Classes\Client\Packages\PkgGUID\Versions\VerGUID\Registry
Indigène	- Emplacement du registre des applications natives

Groupe de connexions VReg

Emplacement	Description
VACHE	- Machine Registry\Client\PackageGroups\GrpGUID\REGISTRY (seul le processus d’élévation de privilèges peut écrire) - Registre utilisateur\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
Indigène	- Emplacement du registre des applications natives

Il existe deux emplacements COW pour HKLM ; processus élevés et non élevés. Les processus avec élévation de privilèges écrivent toujours les modifications HKLM dans le cow sécurisé sous HKLM. Les processus nonlevés écrivent toujours les modifications HKLM dans le cow non sécurisé sous HKCU\Software\Classes. Lorsqu’une application lit les modifications à partir de HKLM, les processus avec élévation de privilèges lisent les modifications à partir du cow sécurisé sous HKLM. Les lectures nonlevées des deux, favorisant d’abord les modifications apportées à la vache non sécurisée.

Clés directes

Les clés directes permettent à un administrateur de configurer certaines clés afin qu’elles puissent uniquement être lues à partir du registre natif, en contournant les emplacements Package et COW. Les emplacements pass-through sont globaux pour l’ordinateur (pas spécifiques au package) et peuvent être configurés en ajoutant le chemin à la clé, qui doit être traitée comme pass-through à la valeur REG_MULTI_SZ appelée PassThroughPaths de la clé HKLM\Software\Microsoft\AppV\Subsystem\VirtualRegistry. Toute clé et ses enfants qui apparaissent sous cette valeur multi-chaîne sont traités comme des clés directes.

Les emplacements suivants sont configurés en tant qu’emplacements direct 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

L’objectif des clés directes est de s’assurer qu’une application virtuelle n’écrit pas de données de Registre dans le VReg requis pour les applications non virtuelles pour une opération ou une intégration réussies. La clé de stratégies garantit que les paramètres basés sur la stratégie de groupe définis par l’administrateur sont utilisés et non pas par paramètres de package. La clé AppModel est requise pour l’intégration avec les applications basées sur l’interface utilisateur moderne Windows. Il est recommandé que les administrateurs ne modifient aucune des clés directes par défaut, mais dans certains cas, en fonction du comportement de l’application, il peut être nécessaire d’ajouter d’autres clés directes.

Comportement du magasin de packages App-V

App-V 5 gère le magasin de packages, qui est l’emplacement où les fichiers de ressources développés du appv fichier sont stockés. Par défaut, cet emplacement est stocké dans %ProgramData%\App-V et est limité en termes de capacités de stockage uniquement 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

Les packages App-V sont mis en lots lors de l’ajout à l’ordinateur avec le client App-V. Le client App-V fournit une préproduction à la demande. Lors de la publication ou d’un Add-AppVClientPackage manuel, la structure de données est générée dans le magasin de packages (c :\programdata\App-V\{PkgGUID}\{VerGUID}). Les fichiers de package identifiés dans le bloc de publication défini dans le StreamMap.xml sont ajoutés au système, ainsi que les dossiers de niveau supérieur et les fichiers enfants intermédiaires pour garantir l’existence des ressources d’application appropriées au lancement.

Montage de packages

Les packages peuvent être chargés explicitement à l’aide de 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 le package entier dans le magasin de packages.

Packages de diffusion en continu

Le client App-V peut être configuré pour modifier le comportement par défaut du streaming. Toutes les stratégies de streaming 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 Set-AppvClientConfigurationPowerShell . Les stratégies suivantes s’appliquent au streaming :

Stratégie	Description
AllowHighCostLaunch	Sur Windows 8 et versions ultérieures, il permet la diffusion en continu sur les réseaux 3G et cellulaires.
Chargement automatique	Spécifie le paramètre 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 racine à partir duquel les packages doivent être diffusés en continu.
SharedContentStoreMode	Active l’utilisation du magasin de contenu partagé pour les scénarios VDI.

Ces paramètres affectent le comportement du streaming des ressources de package App-V vers le client. Par défaut, App-V télécharge uniquement les ressources requises après le téléchargement des blocs de fonctionnalités de publication initiale et de fonctionnalités principales. Il existe trois comportements spécifiques concernant les packages de diffusion en continu qui doivent être expliqués :

• Streaming en arrière-plan

• Diffusion en continu optimisée

• Erreurs de flux

Diffusion en continu en arrière-plan

L’applet de commande Get-AppvClientConfiguration PowerShell peut être utilisée pour déterminer le mode actuel pour la diffusion en continu en arrière-plan avec le paramètre Chargement automatique et modifiée 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 où le paramètre Chargement automatique 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é tous ensemble (valeur=0) ou activé pour tous les packages (valeur=2), qu’ils soient lancés.

Diffusion en continu optimisée

Les packages App-V peuvent être configurés avec un bloc de fonctionnalités principal pendant le séquencement. Ce paramètre permet à l’ingénieur de séquencement de surveiller les fichiers de lancement d’une ou plusieurs applications spécifiques et de marquer les blocs de données dans le package App-V pour la diffusion en continu au premier lancement d’une application dans le package.

Erreurs de flux

Après le flux initial des données de publication et le bloc de fonctionnalité principal, les demandes de fichiers supplémentaires effectuent des erreurs de flux. Ces blocs de données sont téléchargés dans 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 suffisamment pour lancer le package et exécuter des tâches normales. Tous les autres blocs sont téléchargés lorsqu’un utilisateur lance une opération qui nécessite des données qui ne se trouvent pas actuellement dans le magasin de packages.

Mises à niveau de package

Les packages App-V nécessitent une mise à jour tout au long du cycle de vie de l’application. Les mises à niveau de package App-V sont similaires à l’opération de publication de package, car chaque version est créée dans son propre emplacement PackageRoot : %ProgramData%\App-V\{PkgGUID}\{newVerGUID}. L’opération de mise à niveau est optimisée en créant des liens vers des fichiers identiques et diffusés en continu à partir d’autres versions du même package.

Suppression de package

Le comportement du client App-V lors de la suppression des packages 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 de catalogue utilisateur (catalogue de machines pour les applications publiées globalement) sont supprimés, mais conservent l’emplacement du magasin de packages et les emplacements COW. Lorsque l’applet de commande Remove-AppVClientPackge PowerShell 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 d’un package App-V à partir du serveur d’administration n’effectue pas d’opération de suppression. Aucune des deux opérations ne supprime les fichiers de package du magasin de packages.

Registre et données itinérantes

App-V 5 est en mesure de fournir une expérience quasi native lors de l’itinérance, en fonction de la façon dont l’application est écrite. Par défaut, App-V itinérant AppData qui est stocké dans l’emplacement itinérant, en fonction de la configuration itinérante du système d’exploitation. Les autres emplacements de stockage des données basées sur des fichiers ne sont pas itinérants d’un ordinateur à l’autre, car ils se trouvent dans des emplacements qui ne sont pas itinérants.

Configuration requise pour l’itinérance et stockage des données du catalogue utilisateur

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

• Fichiers sous %appdata%\Microsoft\AppV\Client\Catalog

• Paramètres du Registre sous HKEY_CURRENT_USER\Software\Microsoft\AppV\Client\Packages

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

Remarque

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 basées sur le registre

L’itinérance du Registre App-V se présente dans deux scénarios, comme indiqué dans le tableau suivant.

Scénario	Description
Applications exécutées en tant qu’utilisateurs standard	Lorsqu’un utilisateur standard lance une application App-V, HKLM et HKCU pour les applications App-V sont stockés dans la ruche HKCU sur l’ordinateur. Cela 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 en fonction des paramètres du système d’exploitation.
Applications exécutées avec élévation	Lorsqu’une application est lancée avec élévation : - 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 des utilisateurs Dans ce scénario, ces paramètres ne sont pas itinérants avec les configurations d’itinérance du système d’exploitation normales, et les clés et valeurs de Registre qui en résultent 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

Redirection d’app-V et de dossiers

App-V 5.1 prend en charge la redirection de dossiers du dossier AppData itinérant (%AppData%). Lorsque l’environnement virtuel est démarré, l’état AppData itinérant du répertoire AppData itinérant de l’utilisateur est copié dans le cache local. À l’inverse, lorsque l’environnement virtuel est arrêté, le cache local associé à l’AppData itinérant d’un utilisateur spécifique est transféré vers l’emplacement réel du répertoire AppData itinérant de cet utilisateur.

Un package classique a plusieurs emplacements mappés dans le magasin de stockage de l’utilisateur pour les paramètres dans AppData\Local et AppData\Roaming. Ces emplacements sont les emplacements De copie sur écriture qui sont stockés par utilisateur dans le profil de l’utilisateur, et qui sont utilisés pour stocker les modifications apportées aux répertoires VFS du package et pour protéger le package VFS par défaut.

Le tableau suivant indique les emplacements locaux et itinérants, lorsque 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, lorsque la redirection de dossiers est implémentée pour %AppData% et que l’emplacement est 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 dans les emplacements réseau, de sorte que le client App-V détecte la présence d’une redirection de dossiers et copie les données sur le lecteur local pendant la publication et au démarrage de l’environnement virtuel. Une fois que l’utilisateur a fermé l’application App-V et que le client App-V a fermé l’environnement virtuel, le stockage local de l’AppData VFS est copié sur le réseau, ce qui permet l’itinérance vers d’autres machines, où le processus est répété. Les étapes détaillées des processus sont les suivantes :

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

2. Si le chemin d’accès AppData itinérant est local ou si un emplacement AppData\Roaming est mappé, rien ne se passe.

3. Si le chemin AppData itinérant n’est pas local, le répertoire AppData VFS est mappé au répertoire AppData local.

Ce processus résout le problème d’un %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 enregistré dans le Registre : HKEY_CURRENT_USER\Software\Microsoft\AppV\Client\Packages\<GUID>\AppDataTime comme dernier horodatage AppData connu.

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

L’horodatage est utilisé pour déterminer un scénario de « dernier enregistreur gagnant » s’il existe un conflit et est utilisé pour optimiser le téléchargement des données lorsque l’application App-V est publiée ou que l’environnement virtuel est démarré. La redirection de dossiers rend les données disponibles à partir de tous les autres clients couverts par la stratégie de prise en charge et démarre le processus de stockage des données AppData\Roaming dans 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 recherche le fichier ZIP horodaté le plus récent, le cas échéant.

3. Le Registre est vérifié pour le dernier horodatage téléchargé connu, le cas échéant.

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

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

6. Une fois le fichier ZIP 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 données AppData itinérantes les plus récemment enregistrées.

Cela termine l’itinérance réussie des paramètres d’application présents dans les emplacements AppData\Roaming. La seule autre condition qui doit être traitée est 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 d’accès au répertoire AppData itinérant de l’utilisateur n’est pas local.

2. Mapper les cibles de chemin d’accès AppData itinérantes non locales sont recréées les emplacements AppData locaux et itinérants attendus.

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

Ce processus recrée les emplacements locaux et réseau pour AppData et supprime l’enregistrement de Registre de l’horodatage.

Gestion du cycle de vie des applications clientes App-V

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

Ce document se concentre sur les solutions d’infrastructure complète App-V. Pour plus d’informations sur l’intégration d’App-V à Configuration Manager 2012, consultez Configurations prises en charge par App-V 5.1.

Les tâches de cycle de vie de l’application App-V sont déclenchées lors de la connexion de l’utilisateur (par défaut), au démarrage de la machine ou en tant qu’opérations chrono timed 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 du script de package et d’autres, sont configurés lors de l’installation du client ou de la post-installation avec les commandes PowerShell. Consultez la section Guide pratique pour déployer le client sur TechNet à l’adresse : Comment déployer le client App-V ou utiliser PowerShell :

get-command *appv*

Publication de l’actualisation

Le processus d’actualisation de la publication comprend plusieurs opérations plus petites qui se produisent sur le client App-V. Étant donné qu’App-V est une technologie de virtualisation d’application et non une technologie de planification des 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 est la méthode recommandée lors de la distribution du client à un grand groupe d’ordinateurs avec les paramètres appropriés. 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 la publication App-V. Cela est également utilisé dans les tâches planifiées créées lors de la configuration du serveur de publication.

L’objectif des sections suivantes est de détailler les opérations qui se produisent au cours des différentes phases d’une actualisation de publication 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 la publication. Le résultat final est le même que l’applet Add-AppVClientPackage de commande dans PowerShell, sauf pendant le processus d’ajout d’actualisation de publication, le serveur de publication configuré est contacté et transmet une liste générale d’applications au client pour extraire des informations plus détaillées et pas une seule opération d’ajout de package. Le processus se poursuit en configurant le client pour les ajouts ou mises à jour de package ou de groupe de connexions, puis accède au appv fichier. Ensuite, le contenu du appv fichier est développé et placé sur le système d’exploitation local aux emplacements appropriés. Voici un flux de travail détaillé du processus, en supposant que le package est configuré pour le streaming d’erreurs.

Comment ajouter un package App-V

1. Initiation manuelle via PowerShell ou initiation de séquence de tâches du processus d’actualisation de publication.

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

   2. Le serveur de publication App-V utilise l’identité de la cible, de l’utilisateur ou de l’ordinateur initialisateur et 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 d’autres demandes au serveur pour plus d’informations sur une base par package.

2. L’agent de publication sur le client App-V effectue toutes les actions suivantes de manière sérialisée.

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

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

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

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

   3. Flux complet des données de bloc de publication définies dans le StreamMap.xml. Stocke les données de bloc de publication dans le magasin de packages\PkgGUID\VerGUID\Root.

      • Icônes : cibles des points d’extension.

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

      • Scripts : téléchargez le répertoire des scripts à utiliser tout au long du processus de publication.

   4. Remplissez le magasin de packages :

      1. Créez des fichiers partiellement alloués sur le disque qui représentent le package extrait pour tous les répertoires répertoriés.

      2. Phasez les fichiers et répertoires de niveau supérieur sous la racine.

      3. Tous les autres fichiers sont créés lorsque le répertoire est répertorié comme partiellement alloué sur le disque et diffusé en continu à la demande.

   5. Créez les entrées du catalogue de machines. Créez le Manifest.xml et DeploymentConfiguration.xml à partir des fichiers de package (si aucun fichier DeploymentConfiguration.xml dans le package n’est créé d’espace réservé).

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

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

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

   9. Appelez le script à partir du fichier AppxManifest.xml ou DeploymentConfig.xml pour le minutage d’ajout de package.

4. Configurez des groupes de connexions en ajoutant et en activant ou en désactivant.

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

   Remarque

   Cette action ne supprime pas un package. Il supprime les points d’intégration pour la cible spécifique (utilisateur ou ordinateur) et supprime les fichiers de catalogue utilisateur (fichiers catalogue d’ordinateurs pour les fichiers publiés globalement).

6. Appelez le montage de la charge en arrière-plan en fonction de 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.

   Remarque

   Cette condition se produit en tant que produit de suppression sans annulation de publication avec ajout en arrière-plan du package.

Cette opération termine l’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 utilisateur, mappe les droits à l’utilisateur, identifie le magasin local et se termine en effectuant les étapes d’intégration. Voici les étapes détaillées.

Guide pratique pour publier et le package App-V

1. Les entrées de package sont ajoutées au catalogue d’utilisateurs

   1. Packages ciblés par l’utilisateur : les UserDeploymentConfiguration.xml et les UserManifest.xml sont placés sur l’ordinateur dans le catalogue d’utilisateurs

   2. Packages (globaux) ciblés par l’ordinateur : le UserDeploymentConfiguration.xml est placé dans le catalogue de machines

2. Inscrire le package auprès du pilote en mode noyau pour l’utilisateur à l’adresse HKLM\Software\Microsoft\AppV\

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

   1. Créez des points d’extension.

   2. Stockez les informations de sauvegarde dans le registre et le profil itinérant de l’utilisateur (sauvegardes de raccourci).

      Remarque

      Cette action active les points d’extension de restauration si le package n’est pas publié.

   3. Exécuter des scripts ciblés pour le minutage de publication.

La publication d’un package App-V qui fait partie d’un groupe de connexions est similaire au processus précédent. Pour les groupes de connexions, le chemin d’accès qui stocke les informations de catalogue spécifiques inclut PackageGroups en tant qu’enfant du répertoire du catalogue.

Lancement de l’application

Après la publication du processus d’actualisation, l’utilisateur lance, puis relance une application App-V. Le processus est optimisé pour être lancé rapidement avec un minimum de trafic réseau. Le client App-V vérifie le chemin d’accès au catalogue d’utilisateurs pour les fichiers créés lors de la publication. Une fois les droits de lancement du package établis, le client App-V crée un environnement virtuel, commence la diffusion en continu des données nécessaires et applique les fichiers de configuration de manifeste et de déploiement appropriés lors de la création de l’environnement virtuel. Une fois l’environnement virtuel créé et configuré pour le package et l’application spécifiques, l’application démarre.

Guide pratique pour lancer des applications App-V

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

2. Le client App-V vérifie l’existence dans le catalogue d’utilisateurs pour les fichiers suivants

   • UserDeploymentConfiguration.xml

   • UserManifest.xml

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

4. Ensuite, le client App-V vérifie que le chemin du package inscrit pour le service client App-V se trouve dans le Registre.

5. Lorsque vous trouvez le chemin d’accès au magasin de packages, 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 client App-V utilise le manifeste et les fichiers de configuration de déploiement pour configurer l’environnement virtuel et tous les sous-systèmes App-V sont chargés.

7. L’application démarre. Pour tous les fichiers manquants dans le magasin de packages (fichiers partiellement alloués), App-V génère des erreurs sur les fichiers en fonction des besoins.

   

Mise à niveau d’un package App-V

Le processus de mise à niveau du package App-V 5 diffère des anciennes versions d’App-V. App-V prend en charge plusieurs versions du même package sur un ordinateur autorisé à différents utilisateurs. Les versions de package peuvent être ajoutées à tout moment à mesure que le magasin de packages et les catalogues sont mis à jour avec les 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 du magasin de versions et des liens physiques sont créés pour les fichiers inchangés. Cela réduit le stockage global en présentant uniquement le fichier sur un 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 :

Guide pratique pour 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 par l’utilisateur : les UserDeploymentConfiguration.xml et les UserManifest.xml sont placés sur l’ordinateur dans le catalogue utilisateur à l’adresse appdata\roaming\Microsoft\AppV\Client\Catalog\Packages\PkgGUID\VerGUID

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

3. Inscrire le package auprès du pilote en mode noyau pour l’utilisateur à l’adresse HKLM\Software\Microsoft\AppV\

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

   • Intégrez des points d’extensions (EP) à partir des fichiers manifeste et de configuration dynamique.

   1. Les données EP basées sur des fichiers sont stockées dans le dossier AppData à l’aide des points de jonction du magasin de packages.

   2. Les EP de version 1 existent déjà lorsqu’une nouvelle version devient disponible.

   3. Les points d’extension sont basculés vers l’emplacement Version 2 dans les catalogues d’ordinateurs ou d’utilisateurs pour les points d’extension plus récents ou mis à jour.

5. Exécuter des scripts ciblés pour le minutage de publication.

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

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

À compter de App-V 5 SP2 : si vous essayez de mettre à niveau un package utilisé par un utilisateur final, la tâche de mise à niveau est placée dans un état en attente. La mise à niveau s’exécute ultérieurement, selon les règles suivantes :

Type de tâche	Règle applicable
Tâche basée sur l’utilisateur, par exemple, la publication d’un package sur un utilisateur	La tâche en attente s’exécute une fois que l’utilisateur s’est déconnecté, puis se reconnecte.
Tâche globale, par exemple, activation d’un groupe de connexions globalement	La tâche en attente s’exécute lorsque l’ordinateur est arrêté, puis redémarré.

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

Tâche basée sur l’utilisateur ou globale	Emplacement où la clé de Registre est générée
Tâches basées sur l’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 avant 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 spécifique à l’ordinateur et vous pouvez l’effectuer à tout moment en effectuant les étapes décrites dans la section Ajouter un package.
Publier le package	Consultez la section Publication de package pour connaître les étapes à suivre. Ce processus nécessite la mise à jour des points d’extension sur le système. Les utilisateurs finaux ne peuvent pas utiliser l’application lorsque vous effectuez cette tâche.

Utilisez les exemples de scénarios suivants comme guide de mise à jour des packages.

Scénario	Conditions préalables
Le package App-V n’est pas utilisé lorsque vous essayez de mettre à niveau	Aucun des composants suivants du package ne peut être utilisé : application virtuelle, serveur COM ou extensions d’interpréteur de commandes. L’administrateur publie une version plus récente du package et la mise à niveau fonctionne lors du prochain lancement d’un composant ou d’une application à l’intérieur du package. La nouvelle version du package est diffusée en continu et exécutée. Rien n’a changé dans ce scénario dans App-V 5 SP2 par rapport aux versions précédentes d’App-V 5.
Le package App-V est en cours d’utilisation lorsque l’administrateur publie une version plus récente du package	L’opération de mise à niveau est définie sur en attente par le client App-V, ce qui signifie qu’elle est mise en file d’attente et effectuée ultérieurement lorsque le package n’est pas utilisé. Si l’application de package est en cours d’utilisation, l’utilisateur arrête l’application virtuelle, après quoi la mise à niveau peut se produire. Si le package a des extensions shell (Office 2013), qui sont chargées définitivement par l’Explorateur Windows, l’utilisateur ne peut pas être connecté. Les utilisateurs doivent se déconnecter, puis se reconnecter pour démarrer la mise à niveau du package App-V.

Publication globale et publication utilisateur

Les packages App-V peuvent être publiés de l’une des deux manières suivantes. La publication d’utilisateurs donne droit à un package App-V à un utilisateur ou à un groupe d’utilisateurs spécifique. La publication globale autorise le package App-V à l’ensemble de l’ordinateur pour tous les utilisateurs de la machine. Une fois qu’une mise à niveau de package est en attente et que le package App-V n’est pas en cours d’utilisation, envisagez les deux types de publication :

• Globalement publié : l’application est publiée sur un ordinateur ; tous les utilisateurs de cet ordinateur peuvent l’utiliser. La mise à niveau se produit lorsque le service client App-V démarre, ce qui signifie qu’une machine redémarre.

• Utilisateur publié : l’application est publiée sur un utilisateur. S’il y a plusieurs utilisateurs sur l’ordinateur, l’application peut être publiée sur un sous-ensemble des utilisateurs. La mise à niveau se produit lorsque l’utilisateur se connecte ou lorsqu’il est à nouveau publié. Cela se produit régulièrement, avec l’actualisation et l’évaluation de la stratégie Configuration Manager, une publication/actualisation périodique d’App-V ou explicitement 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 et ne démarre pas la suppression de package. Le processus est le même que le processus de publication, mais au lieu d’ajouter le processus de suppression, annule les modifications apportées aux packages App-V.

Réparation d’un package App-V

L’opération de réparation peut affecter de nombreux emplacements sur la machine. Les emplacements de copie sur écriture (COW) mentionnés précédemment sont supprimés, et les points d’extension sont désintégrés, puis réinsérés. Passez en revue les emplacements de placement des données COW en examinant où ils sont inscrits 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 cliente App-V ou via PowerShell (Repair-AppVClientPackage).

Intégration de packages App-V

L’architecture du client et du package App-V fournit une intégration spécifique au 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 utilisateur. Contient les options créées pendant le processus de séquencement.

• DeploymentConfig.xml : fournit des informations de configuration des points d’extension d’intégration basés sur l’ordinateur et l’utilisateur.

• UserConfig.xml : sous-ensemble du Deploymentconfig.xml qui fournit uniquement des configurations basées sur l’utilisateur et qui cible uniquement les points d’extension basés sur l’utilisateur.

Règles d’intégration

Lorsque des applications App-V sont publiées sur un ordinateur avec le client App-V, certaines actions spécifiques sont effectuées comme décrit dans la liste suivante :

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

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

• Sauvegarde et restauration : les données d’application natives existantes et le registre (tels que les inscriptions FTA) sont sauvegardés lors de la publication.

  1. Les packages App-V reçoivent la propriété en fonction du dernier package intégré où la propriété est passée à l’application App-V publiée la plus récente.

  2. La propriété est transférée d’un package App-V à un autre lorsque le package App-V propriétaire n’est pas publié. Ce processus ne démarre pas une restauration des données ou du registre.

  3. Restaurez les données sauvegardées lorsque le dernier package n’est pas publié ou 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’application classiques, telles que le placement de raccourcis, la création d’associations de types de fichiers 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 quelques différences. La liste suivante répertorie les points d’extension abordés dans cette section :

• Raccourcis

• Associations de types de fichiers

• Extensions d’interpréteur de commandes

• COM

• Clients logiciels

• Fonctionnalités de l’application

• Gestionnaire de protocole d’URL

• AppPath

• Application virtuelle

Raccourcis

Le raccourci est l’un des éléments de base de l’intégration au système d’exploitation et est l’interface pour le lancement direct par l’utilisateur d’une application App-V.

À partir du manifeste du package et des fichiers XML de configuration dynamique, le chemin d’accès à un exécutable d’application spécifique se trouve dans une section similaire à l’exemple suivant :

<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. L’actualisation globale place les raccourcis dans le profil Tous les utilisateurs et l’actualisation 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 tokenisé dans le package App-V.

Associations de types de fichiers

Le client App-V gère les associations de types de fichiers du système d’exploitation local lors de la publication, ce qui permet aux utilisateurs d’utiliser des appels de type de fichier ou d’ouvrir un fichier avec une extension inscrite, comme .docx, pour démarrer une application App-V. Les associations de types de fichiers sont présentes dans les fichiers manifeste et de configuration dynamique, comme indiqué dans l’exemple suivant :

<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>

Remarque

Dans cet exemple :

• <Name>.xdp</Name> est l’extension

• <Name>AcroExch.XDPDoc</Name> est la valeur ProgId (qui pointe vers le ProgId adjacent)

• <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 shell sont incorporées automatiquement dans le package pendant le processus de séquencement. Lorsque le package est publié globalement, l’extension shell offre aux utilisateurs les mêmes fonctionnalités que si l’application était installée localement. L’application ne nécessite aucune autre configuration ou configuration sur le client pour activer la fonctionnalité d’extension shell.

Configuration requise pour l’utilisation des extensions d’interpréteur de commandes

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

• Le « nombre de bits » de l’application, du séquenceur et du client App-V doit correspondre, sinon les extensions d’interpréteur de commandes ne fonctionneront pas. Par exemple :

  • La version de l’application est 64 bits.

  • Sequencer s’exécute sur un ordinateur 64 bits.

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

Le tableau suivant affiche les extensions d’interpréteur de commandes prises en charge.

Gestionnaire	Description
Gestionnaire de menu contextuel	Ajoute des éléments de menu au menu contextuel. Il est appelé avant l’affichage du menu contextuel.
Gestionnaire de glisser-déplacer	Contrôle l’action lors d’un clic droit sur glisser-déplacer et modifie le menu contextuel qui s’affiche.
Drop target handler	Contrôle l’action après qu’un objet de données est glissé et déposé sur une cible de déplacement telle qu’un fichier.
Gestionnaire d’objets de données	Contrôle l’action après qu’un fichier a été copié dans le Presse-papiers ou glissé sur une cible de déplacement. Il peut fournir d’autres formats de Presse-papiers à la cible de déplacement.
Gestionnaire de feuille de propriétés	Remplace ou ajoute des pages à la boîte de dialogue de feuille de propriétés d’un objet.
Gestionnaire d’info-bulles	Permet de récupérer des indicateurs et des informations d’info-bulle pour un élément et de l’afficher à l’intérieur d’une info-bulle contextuelle lors du pointage 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. Il peut être utilisé pour étendre le tri et le regroupement.
Gestionnaire d’aperçu	Permet d’afficher un aperçu d’un fichier dans le volet Aperçu de l’Explorateur Windows.

COM

Le client App-V prend en charge la publication d’applications avec prise en charge de l’intégration et de la virtualisation COM. L’intégration COM permet au client App-V d’inscrire des objets COM sur le système d’exploitation local et la virtualisation des objets. Pour les besoins de ce document, l’intégration d’objets COM nécessite plus de détails.

App-V prend en charge l’inscription d’objets COM à partir du package sur le système d’exploitation local avec deux types de processus : hors processus et in-process. L’inscription d’objets COM s’effectue avec un ou une combinaison de plusieurs modes de fonctionnement pour un package App-V spécifique qui inclut off, Isolé et Intégré. Le mode intégré est configuré pour le type hors processus ou in-process. La configuration des modes et types COM s’effectue avec des fichiers de configuration dynamiques (deploymentconfig.xml ou userconfig.xml).

Clients logiciels et fonctionnalités d’application

App-V prend en charge des clients logiciels et des points d’extension de fonctionnalités d’application spécifiques qui permettent aux applications virtualisées d’être inscrites 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 telles que la messagerie électronique, la messagerie instantanée et le lecteur multimédia. Cette opération est effectuée dans le panneau de configuration avec l’option Définir l’accès au programme et les paramètres par défaut de l’ordinateur, et configurée pendant le séquencement dans le manifeste ou les fichiers de configuration dynamique. Les fonctionnalités d’application ne sont prises en charge que lorsque les applications App-V sont publiées globalement.

Exemple d’inscription de client logiciel d’un client de messagerie basé sur 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>

Remarque

Dans cet exemple :

• <ClientConfiguration EmailEnabled="true" /> est le paramètre Global Software Clients pour intégrer les clients de messagerie

• <EMail MakeDefault="true"> est l’indicateur permettant de définir un client de messagerie particulier comme client de messagerie par défaut

• <MAPILibrary>[{ProgramFilesX86}]\Mozilla Thunderbird\mozMapi32_InUse.dll</MAPILibrary> est l’inscription de dll MAPI

Gestionnaire de protocole d’URL

Les applications n’appellent pas toujours les applications virtualisées utilisant l’appel de type de fichier. Par exemple, une application prend en charge l’incorporation d’un mailto: lien à l’intérieur d’un document ou d’une page web. L’utilisateur sélectionne le mailto: lien et s’attend à obtenir son client de messagerie inscrit. App-V prend en charge les gestionnaires de protocole d’URL que vous pouvez inscrire auprès de Windows pour chaque package. Pendant le séquencement, les gestionnaires de protocole d’URL sont automatiquement ajoutés au package.

Dans les situations où plusieurs applications peuvent inscrire le gestionnaire de protocole d’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 l’application principale lancée.

AppPath

Le point d’extension AppPath prend en charge l’appel d’applications App-V directement à partir de Windows. Ce comportement se produit généralement à partir de l’écran d’exécution ou de démarrage. Vous pouvez fournir l’accès aux applications App-V à partir de commandes ou de scripts de système d’exploitation sans appeler le chemin d’accès spécifique à l’exécutable. Cela évite de modifier la variable d’environnement de chemin d’accès système sur tous les systèmes, comme cela se produit lors de la publication.

Le point d’extension AppPath est configuré dans le manifeste ou dans les fichiers de configuration dynamiques et est stocké dans le Registre sur l’ordinateur local lors de la publication pour l’utilisateur.

Application virtuelle

Ce sous-système fournit une liste des applications capturées pendant le séquencement, qui est généralement consommée par d’autres composants App-V. L’intégration de points d’extension appartenant à une application particulière peut être désactivée à l’aide de fichiers de configuration dynamiques. 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 d’une autre application.

Règles de point d’extension

Les points d’extension sont intégrés au système d’exploitation en fonction de la façon dont les packages sont publiés. La publication globale place les points d’extension dans les emplacements d’ordinateurs publics, où la publication utilisateur place les points d’extension dans les emplacements utilisateur. Par exemple, un raccourci créé sur le bureau et publié globalement génère les données du fichier pour le raccourci (%Public%\Desktop) et les données de Registre (HKLM\Software\Classes). Le même raccourci contient des données de fichier (%UserProfile%\Desktop) et des données de Registre (HKCU\Software\Classes).

Les points d’extension ne sont pas tous publiés de la même façon. Certains points d’extension nécessitent une publication globale. D’autres nécessitent un séquencement sur le système d’exploitation et l’architecture spécifiques où ils sont fournis. Le tableau suivant décrit ces deux règles clés.

Extension virtuelle	Nécessite le séquencement du système d’exploitation cible	Nécessite la publication globale
Raccourci
Association de types de fichiers
Protocoles d’URL	X
AppPaths	X
COM Mode
Client logiciel	X
Fonctionnalités de l’application	X	X
Gestionnaire de menu contextuel	X	X
Gestionnaire de glisser-déplacer	X
Gestionnaire d’objets de données	X
Gestionnaire de feuilles de propriétés	X
Gestionnaire d’info-bulles	X
Gestionnaire de colonnes	X
Extensions d’interpréteur de commandes	X
Objet Browser Helper	X	X
Objet X actif	X	X

Traitement de la configuration dynamique

À mesure que les organisations déploient des applications App-V au-delà des secteurs d’activité et des limites géographiques et politiques, la possibilité de séquencer une application une seule fois avec un ensemble de paramètres devient impossible. App-V a été conçu pour ce scénario, car il capture des paramètres et des configurations spécifiques lors du séquencement dans le fichier manifeste, mais prend également en charge la modification avec les fichiers de configuration dynamiques.

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 de groupes individuels d’utilisateurs ou de machines. Dans certains cas, vous devrez peut-être apporter des modifications à l’application pour fournir des fonctionnalités appropriées dans l’environnement App-V. Par exemple, vous devrez peut-être apporter des modifications aux _*config.xml fichiers pour permettre l’exécution de certaines actions à un moment spécifié 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 d’une autre application.

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

Exemple de fichiers de configuration dynamique

L’exemple de manifeste suivant montre la combinaison des fichiers de manifeste, de configuration de déploiement et de configuration utilisateur après la publication et pendant le fonctionnement normal. Ces exemples sont des exemples abrégés de chacun des fichiers. L’objectif est d’afficher la combinaison des fichiers uniquement et de ne pas être une description complète des catégories spécifiques disponibles dans chacun des fichiers.

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 de l’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:Icon>[{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:Icon>[{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 (SxS) pendant le séquencement et le déploiement sur le client pendant la publication de l’application virtuelle. App-V 5 SP2 prend en charge la capture des assemblys SxS pendant le séquencement pour les assemblys qui ne sont pas présents sur l’ordinateur de séquencement. Pour les assemblys qui utilisent Visual C++ version 8 et ultérieure et/ou l’exécution MSXML, le séquenceur détecte et capture automatiquement ces dépendances. Ce comportement se produit même s’ils n’ont pas été installés pendant la surveillance. La fonctionnalité assemblys SxS supprime les limitations des versions précédentes d’App-V. Auparavant, le séquenceur App-V ne capturait pas les assemblys déjà présents sur la station de travail de séquencement et ne privatisait pas les assemblys, ce qui se limitait à la version un bits par package. Ce comportement a entraîné l’absence des assemblys SxS requis pour les applications App-V déployées sur les clients, ce qui a entraîné des échecs de lancement d’application. Cela a forcé le processus d’empaquetage à documenter, puis à vérifier que tous les assemblys requis pour les packages étaient installés localement sur le système d’exploitation client de l’utilisateur afin de garantir la prise en charge des applications virtuelles. En fonction du nombre d’assemblys et de l’absence de documentation d’application pour les dépendances requises, cette tâche a été à la fois un défi de gestion et d’implémentation.

La prise en charge des assemblys SxS dans App-V offre les fonctionnalités suivantes.

• Captures automatiques de l’assembly SxS pendant le séquencement, que l’assembly ait ou non été installé sur la station de travail de séquencement.

• Le client App-V installe automatiquement les assemblys SxS requis sur l’ordinateur client au moment de la publication lorsqu’ils ne sont pas présents.

• Le sequencer signale la dépendance au moment de l’exécution vc dans le mécanisme de création de rapports sequencer.

• Le sequencer permet de ne pas empaqueter les assemblys déjà installés sur le séquenceur. Il prend en charge les scénarios où les assemblys ont été précédemment installés sur les ordinateurs cibles.

Publication automatique des assemblys SxS

Lors de la publication d’un package App-V avec des assemblys SxS, le client App-V vérifie la présence de l’assembly sur l’ordinateur. Si l’assembly n’existe pas, le client déploie l’assembly sur l’ordinateur. Les packages qui font partie des groupes de connexions s’appuient sur les installations d’assembly SxS qui font partie des packages de base, car le groupe de connexions ne contient aucune information sur l’installation de l’assembly.

Remarque

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

Journalisation des clients

Le client App-V enregistre les informations dans le journal des événements Windows et utilise le format ETW standard. Les événements App-V spécifiques se trouvent dans l’observateur d’événements, sous Journaux des applications et des services\Microsoft\AppV\Client.

Remarque

Dans App-V 5.0 SP3, certains journaux ont été consolidé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 À propos d’App-V 5.0 SP3.

Il existe trois catégories d’événements spécifiques enregistrées :

Admin : journalise 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 générale d’App-V et l’utilisation de composants individuels, créant un journal d’audit des opérations app-V terminées sur le client App-V.

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