Publication d’applications et interaction client

S’applique à :

• Windows 10
• Windows 11

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 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 des fichiers .appv manuellement ou à l’aide d’une plateforme de déploiement tierce.
_DeploymentConfig.XML	Fichier utilisé pour personnaliser les paramètres de publication par défaut pour toutes les applications dans 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	Facultatif : fichier accélérateur de package utilisé pour reconstruire automatiquement un package d’application virtuelle séquencé précédemment.
.appvt	Facultatif : fichier de modèle Sequencer utilisé pour conserver les paramètres sequencer couramment réutilisés.

Pour en savoir plus sur le séquencement, consultez Comment séquencer une nouvelle application avec App-V.

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

Le fichier appv est un conteneur qui stocke des 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 fichier appv, effectuez une copie du package, puis renommez le fichier copié en extension .zip.

Le fichier appv 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
Racine	Dossier de fichiers	Répertoire qui contient le système de fichiers pour l’application virtualisée capturée pendant le séquencement.
[Content_Types].xml	Fichier XML	Liste des principaux types de contenu dans le fichier appv (par exemple, DLL, EXE, BIN).
AppxBlockMap.xml	Fichier XML	Disposition du fichier appv, 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 (tels que les répertoires, les fichiers, les répertoires opaques, les répertoires vides et les 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 .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 qui ont été 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 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 pour les 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 des packages publiés globalement (Ruche de machine).
Registre des utilisateurs	HKCU\Software\Microsoft\AppV	Contient des informations sur l’état du package utilisateur, notamment VReg.
Classes de Registre utilisateur	HKCU\Software\Classes\AppV	Contient plus d’informations sur l’état du package utilisateur.

Pour plus d’informations sur le tableau, consultez la section ci-dessous et tout au long du document.

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 l’applet de commande Set-AppVClientConfiguration Windows PowerShell, 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 version.

Voici un 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 Activer le client de bureau 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). Dans les environnements VDI où le stockage local peut être limité, il est important d’utiliser le moins d’espace disque possible. Vous pouvez réduire l’utilisation de l’espace disque en diffusant en continu des applications à partir d’un emplacement réseau hautes performances (par exemple, un RÉSEAU SAN). Pour plus d’informations, consultez Magasin de contenu partagé dans Microsoft App-V 5.0 - En arrière-plan.

Remarque

L’ordinateur 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 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 à un utilisateur spécifique, et le catalogue utilisateur stocke les informations applicables à un utilisateur spécifique. Le catalogue est une collection de configurations dynamiques et de fichiers manifeste ; il existe des données discrètes pour le fichier et le registre par version de package.

Catalogue de machines

Les emplacements décrits dans ce tableau se trouvent dans le dossier %programdata%\Microsoft\AppV\Client\Catalog\.

	Emplacement
Description	Stocke les documents de package qui sont disponibles pour les utilisateurs sur l’ordinateur lorsque 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 toujours des ressources globales qui sont modifiées et visibles par tous les utilisateurs sur l’ordinateur client (par exemple, lorsque le répertoire du package se trouve 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 machines. Lorsqu’un package est publié globalement, il existe un fichier de configuration dynamique, stocké dans le catalogue de machines ; par conséquent, la détermination de la valeur globale d’un package est définie selon qu’il existe ou non un fichier de stratégie (fichier UserDeploymentConfiguration) dans le catalogue de machines.
Emplacement de stockage par défaut	%programdata%\Microsoft\AppV\Client\Catalog<br> 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é)
Emplacement du catalogue de machines supplémentaire, utilisé lorsque le package fait partie d’un groupe de connexions	L’emplacement suivant s’ajoute à l’emplacement de package spécifique mentionné précédemment comme emplacement de stockage par défaut : %programdata%\Microsoft\AppV\Client\Catalog\PackageGroups\ConGroupGUID\ConGroupVerGUID
Fichiers supplémentaires 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

Les emplacements décrits dans ce tableau se trouvent dans le dossier appdata\roaming\Microsoft\AppV\Client\Catalog\.

	Emplacement
Description	Créé pendant le processus de publication. Contient des informations utilisées pour publier le package et pour s’assurer qu’un package est approvisionné pour un utilisateur spécifique au lancement. 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	appdata\roaming\Microsoft\AppV\Client\Catalog\Packages\PkgGUID\VerGUID
Fichiers dans le catalogue utilisateur	- UserManifest.xml - DynamicConfiguration.xml ou UserDeploymentConfiguration.xml
Emplacement du catalogue d’utilisateurs supplémentaire, utilisé lorsque le package fait partie d’un groupe de connexions	L’emplacement suivant s’ajoute à l’emplacement spécifique du package mentionné ci-dessus : appdata\roaming\Microsoft\AppV\Client\Catalog\PackageGroups\PkgGroupGUID\PkgGroupVerGUID
Fichier supplémentaire 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 aux points d’intégration de restaurer 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. Toutefois, ces modifications ne sont pas apportées dans le magasin de packages pour préserver votre capacité à réparer l’application, ce qui supprime ces modifications. Ces emplacements, appelés Copy on Write (COW), prennent 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 a été programmée pour écrire les modifications dans une expérience native.

Itinérance COW

L’emplacement COW Roaming décrit ci-dessus stocke les modifications apportées aux fichiers et répertoires qui sont ciblés sur 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 a été 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 y aura deux emplacements pour tous les emplacements Windows classiques (par exemple, Common AppData et Common AppDataS). La valeur S indique 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, une copie du registre. Le fichier DAT du package est créé dans %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 du package dans un autre emplacement sous 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 spécifique à l’utilisateur HKCU\Software\Microsoft\AppV\Client\Packages\PackageGUID\Registry\User. 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 de machine intermédiaire 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. Cette fonctionnalité signifie que le VREG doit combiner jusqu’à trois emplacements de Registre distincts dans une seule vue en fonction des emplacements remplis dans lepackage>COW>du registre natif. Lorsqu’une demande de données de registre est effectuée, elle localise dans l’ordre jusqu’à ce qu’elle trouve les données demandées. Cela signifie que si une valeur est stockée dans un emplacement COW, elle ne passe pas à d’autres emplacements. Toutefois, s’il n’y a pas de données dans l’emplacement COW, elle 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

Les registres du tableau suivant se trouvent dans le dossier Registry\Client\Packages\PkgGUID\.

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
Natif	- Emplacement du registre des applications natives

Groupe de connexions VReg

Les registres du tableau suivant se trouvent dans les dossiers Machine Registry\Client\PackageGroups\GrpGUID\ et User Registry Classes\Client\PackageGroups\GrpGUID\.

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
Natif	- Emplacement du registre des applications natives

Il existe deux emplacements COW pour HKLM : les processus avec élévation de privilèges et les processus 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 sans élévation de privilèges é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 de la vache sécurisée sous HKLM. Lectures non élevées des deux, ce qui favorise d’abord les modifications apportées à l’élément COW non sécurisé.

Clés directes

Un administrateur peut utiliser des clés directes pour configurer certaines clés à lire uniquement à partir du registre natif, en contournant les emplacements Package et COW. Les emplacements pass-through sont globaux pour l’ordinateur (non spécifiques au package) et peuvent être configurés en ajoutant le chemin d’accès à la clé, qui doit être traitée comme directe à 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 multi-chaîne (et leurs enfants) sera traitée comme directe.

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é Stratégies garantit que les paramètres basés sur les stratégie de groupe définis par l’administrateur sont utilisés et non par package. La clé AppModel est requise pour l’intégration avec les applications windows modernes basées sur l’interface utilisateur. Dans l’idéal, les administrateurs ne doivent pas modifier les clés directes par défaut, mais dans certains cas, l’administrateur peut avoir besoin d’ajouter d’autres clés directes pour ajuster le comportement de l’application.

Comportement du magasin de packages App-V

App-V gère le magasin de packages, qui est l’emplacement où les fichiers de ressources développés à partir du fichier appv 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 de l’entrée manuelle de l’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 de package identifiés dans le bloc de publication défini dans le fichier StreamMap.xml sont ajoutés au système, et les dossiers de niveau supérieur et les fichiers enfants sont intermédiaires pour s’assurer que les ressources d’application appropriées existent au lancement.

Montage de packages

Les packages peuvent être chargés explicitement en entrant l’applet de commande PowerShell Mount-AppVClientPackage ou en utilisant 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 de la diffusion en continu. 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 en entrant l’applet de commande PowerShell Set-AppvClientConfiguration . Les stratégies suivantes s’appliquent à la diffusion en continu :

Stratégie	Description
AllowHighCostLaunch	Autorise la diffusion en continu sur les réseaux 3G et cellulaires
Autoload	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 est important de comprendre trois comportements spécifiques dans les packages de streaming :

• Streaming en arrière-plan
• Diffusion en continu optimisée
• Erreurs Stream

Diffusion en continu en arrière-plan

L’applet de commande Windows PowerShell Get-AppvClientConfiguration peut être utilisée pour déterminer le mode actuel de 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é complètement (valeur=0) ou activé pour tous les packages (valeur=2), qu’ils soient ou non 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 Stream

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. Cette flexibilité 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 sera 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 lorsque les packages sont supprimés dépend de la méthode de suppression de package. À 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 l’emplacement du magasin de packages et les emplacements COW restent. Lorsque l’applet de commande Remove-AppVClientPackge Windows 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 est en mesure de fournir une expérience quasi native lors de l’itinérance, en fonction de la façon dont l’application utilisée 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. Ce scénario présente deux chemins distincts : - L’emplacement de HKLM est HKCU\SOFTWARE\Classes\AppV\Client\Packages\{PkgGUID}\REGISTRY\MACHINE\SOFTWARE - L’emplacement de HKCU est 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 aux emplacements suivants : - L’emplacement de HKLM est HKLM\SOFTWARE\Microsoft\AppV\Client\Packages\{PkgGUID}\{UserSID}\REGISTRY\MACHINE\SOFTWARE - L’emplacement de HKCU est HKCU\SOFTWARE\Microsoft\AppV\Client\Packages\{PkgGUID}\Registry\User\{UserSID}\SOFTWARE

Redirection d’app-V et de dossiers

App-V 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\Local\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\ProgramFilesX86
SystemX86	C :\Users\username\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\SystemX86
Windows	C :\Users\username\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\Windows
appv_ROOT	C :\Users\username\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\appv_ROOT
Appdata	C :\Users\username\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\AppData

Le tableau suivant indique les emplacements locaux et itinérants lorsque 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\Local\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\ProgramFilesX86
SystemX86	C :\Users\Local\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\SystemX86
Windows	C :\Users\Local\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\Windows
appv_ROOT	C :\Users\Local\AppData\Local\Microsoft\AppV\Client\VFS\<GUID>\appv_ROOT
Appdata	\Fileserver\users\Local\roaming\Microsoft\AppV\Client\VFS\<GUID>\AppData

Le pilote VFS du client App-V actuel ne peut pas écrire dans les emplacements réseau. Le client App-V détecte donc la présence de 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é. Voici ce qui se passe pendant le processus :

1. Lors du démarrage de l’environnement virtuel ou de la publication, 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 aucun emplacement AppData\Roaming n’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é. Le processus effectue les opérations suivantes :

1. Arrête l’application App-V, qui arrête également l’environnement virtuel.
2. Compresse le cache local de l’emplacement AppData itinérant et le stocke dans un fichier .zip.
3. Utilise l’horodatage à la fin du processus d’empaquetage .zip pour nommer le fichier.
4. Enregistre l’horodatage dans le registre HKEY_CURRENT_USER\Software\Microsoft\AppV\Client\Packages\<GUID>\AppDataTime en tant que dernier horodatage AppData connu.
5. Appelle le processus de redirection de dossiers 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 » en cas de 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 lance le processus de stockage des données AppData\Roaming dans l’emplacement AppData local sur le client. Voici ce qui se passe pendant le processus :

1. L’utilisateur démarre une application, qui démarre également l’environnement virtuel.
2. L’environnement virtuel de l’application recherche le fichier .zip horodaté le plus récent, le cas échéant.
3. L’environnement virtuel vérifie dans le registre le dernier horodatage téléchargé connu, le cas échéant.
4. L’environnement virtuel télécharge le fichier .zip le plus récent, sauf si le dernier horodatage de chargement local connu est supérieur ou égal à l’horodatage du fichier .zip.
5. Si l’horodatage de chargement local connu est antérieur à celui du fichier .zip le plus récent dans l’emplacement AppData itinérant, l’environnement virtuel extrait le fichier .zip dans le répertoire temporaire 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 données AppData itinérantes les plus récemment enregistrées.

Ce processus 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. Le processus effectue les opérations suivantes :

1. Pendant la réparation, détecte si le chemin d’accès au répertoire AppData itinérant de l’utilisateur n’est pas local.
2. Mappe les cibles de chemin d’accès AppData itinérantes non locales, en recréant les emplacements AppData locaux et itinérants attendus.
3. Supprime l’horodatage stocké dans le Registre, le cas échéant.

Ce processus recréera les emplacements locaux et réseau pour AppData et supprimera 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 entrées sous forme de commandes PowerShell 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 avec Microsoft Configuration Manager, consultez Déployer des applications virtuelles App-V avec Configuration Manager.

Les tâches de cycle de vie des applications 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 tempéré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 des scripts de package et d’autres, sont configurés (une fois le client activé) avec des commandes Windows PowerShell. Consultez Paramètres de configuration du client App-V : Windows PowerShell.

Publication de l’actualisation

Le processus d’actualisation de publication comprend plusieurs opérations plus petites qui sont effectuées 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 lorsque l’utilisateur se connecte, que la machine s’allume et à intervalles planifiés. La configuration du client pendant l’installation répertoriée dans la section précédente 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 Windows 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. Ce processus est également utilisé dans les tâches planifiées créées lors de la configuration du serveur de publication.

Les sections suivantes décrivent ce qui se passe pendant le processus d’actualisation de la publication.

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 de commande Add-AppVClientPackage dans Windows PowerShell, sauf que le processus d’ajout d’actualisation de publication contacte le serveur de publication configuré et transmet une liste générale d’applications au client pour extraire des informations plus détaillées, au lieu d’effectuer une seule opération d’ajout de package.

Le processus configure ensuite le client pour les ajouts ou mises à jour de package ou de groupe de connexions, puis accède 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. Les étapes suivantes sont 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. Lancez l’installation manuellement via Windows PowerShell ou l’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 davantage de demandes au serveur pour plus d’informations par package.

2. L’Agent de publication sur le client App-V évalue 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 les opérations d’ajout ou de mise à jour .

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

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

   3. Diffusez en continu les données de bloc de publication définies dans le fichier StreamMap.xml . Les données de bloc de publication sont stockées dans 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, accessibles directement 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 en effectuant les sous-étapes suivantes :

      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. Placez les fichiers et répertoires de niveau supérieur sous la racine.

         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 les fichiersManifest.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éez 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. Inscrivez le package auprès du pilote de mode noyau App-V à l’adresse HKLM\Microsoft\Software\AppV\MAV.

   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

   Cela n’effectuera pas de suppression de package, mais supprimera plutôt les points d’intégration pour la cible spécifique (utilisateur ou ordinateur) et supprimera les fichiers de catalogue utilisateur (fichiers catalogue de machines 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.

Ce processus termine l’ajout d’un package App-V pour le processus d’actualisation de publication. L’étape suivante consiste à publier le package sur une cible spécifique (ordinateur ou utilisateur).

Ajouter des données de fichier et de registre dans le package

Publication d’un package App-V

Pendant l’opération d’actualisation de la 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.

Comment publier un package App-V

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

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

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

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

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

      Cela 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 faisant partie d’un groupe de connexions est similaire au processus ci-dessus. 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 de catalogues. Pour plus d’informations, passez en revue les informations du catalogue des ordinateurs et des utilisateurs dans les sections précédentes.

Ajouter des données de fichier et de registre dans le package ( global)

Lancement de l’application

Après le processus d’actualisation de la publication, l’utilisateur lance puis relance une application App-V. Le client App-V vérifie le chemin d’accès au catalogue d’utilisateurs pour les fichiers créés lors de la publication. Après avoir établi les droits de lancement du package, 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. Cela peut sembler beaucoup, mais le processus en action est rapide et optimisé pour réduire le trafic réseau.

Guide pratique pour lancer des applications App-V

1. L’utilisateur lance l’application en sélectionnant 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éé.

   Si cette exécution de processus est le 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 les fichiers manquants dans le magasin de packages (fichiers partiellement alloués), App-V diffuse en continu les fichiers d’erreur en fonction des besoins.

   

   Ajouter des données de fichier et de registre dans le package ( flux)

Mise à niveau d’un package App-V

La version actuelle du processus de mise à niveau de package d’App-V diffère des versions antérieures dans son optimisation du stockage. 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, car le magasin de packages et les catalogues sont mis à jour avec les nouvelles ressources. Lors d’une mise à niveau dans la nouvelle version, 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. Ces résultats réduisent 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.

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 fichiers UserDeploymentConfiguration.xml et 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. Inscrivez le package auprès du pilote en mode noyau pour l’utilisateur à l’adresse HKLM\Software\Microsoft\AppV\MAV.

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

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

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

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

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

Si vous essayez de mettre à niveau un package actuellement utilisé, la tâche de mise à niveau est placée dans un état en attente. La mise à niveau s’exécutera ultérieurement, selon les règles suivantes :

Type de tâche	Règle applicable
Tâches basées sur l’utilisateur, telles que la publication d’un package sur un utilisateur	La tâche en attente est effectuée une fois que l’utilisateur se déconnecte, puis se reconnecte.
Tâches globales, telles que l’activation d’un groupe de connexions globalement	La tâche en attente est exécutée 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	HKEY_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 Comment ajouter un package App-V.
Publier le package	Pour connaître les étapes, consultez la section Publication de package ci-dessus. Ce processus nécessite la mise à jour des points d’extension sur le système. Vous ne pouvez pas effectuer cette tâche tant que l’application est en cours d’utilisation.

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.
Le package App-V est en cours d’utilisation lorsque l’administrateur publie une version plus récente du package	Le client App-V définit l’opération sur « en attente », ce qui signifie qu’elle est mise en file d’attente et sera 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, qui sont chargées définitivement par Windows Explorer, l’utilisateur ne pourra pas se connecter. Les utilisateurs doivent se déconnecter, puis se reconnecter pour lancer 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 : en tant qu’utilisateur, qui donne droit à un package App-V à un utilisateur ou à un groupe d’utilisateurs spécifique, ou en tant qu’utilisateur global, qui autorise le package App-V à l’ensemble de l’ordinateur pour tous les utilisateurs de l’ordinateur. Une fois qu’une mise à niveau de package a été bloquée et que le package App-V n’est pas en cours d’utilisation, envisagez les deux types de publication :

• La publication globale se produit lorsque l’application est publiée sur un ordinateur ; tous les utilisateurs de cet ordinateur peuvent l’utiliser. La mise à niveau se produit au démarrage du service client App-V, ce qui signifie en fait un redémarrage de la machine.
• La publication par l’utilisateur se produit lorsque 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é (périodiquement, ConfigMgr l’actualisation et l’évaluation de la stratégie, ou une publication/actualisation périodique d’App-V, ou explicitement via des commandes Windows 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 n’effectue pas de suppression de 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 pour les packages App-V.

Réparation d’un package App-V

L’opération de réparation est facile à faire, mais 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. Avant de procéder à la réparation, vérifiez où les emplacements de placement des données COW sont inscrits dans le registre. Pour effectuer une opération de réparation, il vous suffit de la lancer à partir de la console cliente App-V ou via l’applet de commande PowerShell Repair-AppVClientPackage . Après cela, l’opération est effectuée automatiquement.

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 est 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 est un sous-ensemble du fichier Deploymentconfig.xml qui fournit uniquement des configurations basées sur l’utilisateur et 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 se produisent 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 et le registre d’application natifs existants (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 transfert ne lancera pas de 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 pour intégrer l’application 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. Voici la liste des points d’extension couverts dans cette section :

• Raccourcis
• Associations de types de fichiers
• Extensions d'environnement
• 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. Lors de la publication et de l’annulation de la publication d’applications App-V.

À partir du manifeste de 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, comme illustré dans l’exemple suivant :

<Extension Category="AppV.Shortcut">
          <Shortcut>
            <File>[{Common Desktop}]\Adobe Reader.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

Les utilisateurs peuvent utiliser des appels de type de fichier ou ouvrir un fichier avec une extension inscrite (.docx) pour démarrer une application App-V, car le client App-V gère les associations de types de fichiers du système d’exploitation local lors de la publication. Les associations de types de fichiers sont présentes dans les fichiers manifeste et de configuration dynamique, comme illustré 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</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 configuration ou configuration supplémentaire sur le client pour activer la fonctionnalité d’extension d’interpréteur de commandes.

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, de Sequencer et du client App-V doit correspondre, sinon les extensions d’interpréteur de commandes ne fonctionneront pas. L’exemple de configuration suivant répond à la condition de correspondance :
  • 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, comme 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 davantage de 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 Windows Explorer. 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 Windows Explorer.

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 dans 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 Désactivé, 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).

Pour plus d’informations sur l’intégration d’App-V, consultez Intégration de Microsoft Application Virtualization 5.0.

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 pour inscrire des applications virtualisées auprès du client logiciel du système d’exploitation. Cette prise en charge spécifique signifie que les utilisateurs peuvent sélectionner des programmes par défaut pour des opérations telles que la messagerie électronique, la messagerie instantanée et l’utilisation du lecteur multimédia. Cette opération est effectuée dans le panneau de configuration avec Définir l’accès au programme et les paramètres par défaut de l’ordinateur, et est configurée lors du 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.

L’exemple suivant illustre l’inscription 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 Email clients.
• <EMail MakeDefault="true">est l’indicateur permettant de définir un client Email particulier comme client Email par défaut.
• <MAPILibrary>[{ProgramFilesX86}]\Mozilla Thunderbird\mozMapi32_InUse.dll</MAPILibrary> est l’inscription de dll MAPI.

Gestionnaire de protocole d’URL

Les applications virtuelles n’utilisent pas toujours spécifiquement l’appel de type de fichier. Par exemple, dans une application qui prend en charge l’incorporation d’un lien mailto : à l’intérieur d’un document ou d’une page web, l’utilisateur sélectionne le lien en attendant d’accéder à son client de messagerie inscrit. App-V prend en charge les gestionnaires de protocole URL qui peuvent être inscrits 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.

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

AppPath

Le point d’extension AppPath prend en charge l’appel d’applications App-V directement à partir du système d’exploitation. Les administrateurs peuvent 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 à l’exécutable à partir de l’écran d’exécution ou de démarrage, selon le système d’exploitation. Il évite donc de modifier la variable d’environnement de chemin d’accès système sur tous les systèmes, car elle est effectuée 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. Pour plus d’informations sur AppPath, consultez : Chemins d’accès aux applications - Extension d’application virtuelle dans App-V 5.0.

Application virtuelle

Ce sous-système fournit une liste d’applications capturées pendant le séquencement, qui est consommée par d’autres composants App-V. L’intégration de points d’extension appartenant à une application spécifique peut être désactivée à l’aide de fichiers de configuration dynamiques. Par exemple, si un package contient deux applications, vous pouvez désactiver tous les points d’extension appartenant à une application pour autoriser uniquement l’intégration des points d’extension pour l’autre application.

Règles de point d’extension

Les points d’extension décrits précédemment sont intégrés au système d’exploitation en fonction de la façon dont les packages ont été 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 entraîne les données du fichier pour le raccourci (%Public%\Desktop) et les données de Registre (HKLM\Software\Classes). Le même raccourci aurait 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, où certains points d’extension nécessitent une publication globale et d’autres nécessitent un séquencement sur le système d’exploitation et l’architecture spécifiques où ils sont fournis. Vous trouverez ci-dessous un tableau qui décrit ces deux règles clés.

Extension virtuelle	Nécessite le séquencement du système d’exploitation cible	Nécessite une 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

Le déploiement de packages App-V sur un seul ordinateur ou utilisateur est simple. Toutefois, à mesure que les organisations déploient des applications App-V au-delà des secteurs d’activité et des limites géographiques et politiques, il devient impossible de séquencer toutes les applications avec les mêmes paramètres. App-V a été conçu pour résoudre ce problème en capturant des paramètres et des configurations spécifiques pendant le séquencement dans le fichier manifeste, tout en prenant en charge la modification avec les fichiers de configuration dynamique.

La configuration dynamique App-V vous permet de spécifier une stratégie de package au niveau de l’ordinateur ou de l’utilisateur. Les ingénieurs de séquencement peuvent utiliser des fichiers de configuration dynamique pour modifier la configuration d’un package post-séquencement afin de répondre aux besoins de groupes individuels d’utilisateurs ou de machines. Dans certains cas, il peut être nécessaire de modifier l’application pour fournir les fonctionnalités appropriées dans l’environnement App-V. Par exemple, vous devrez peut-être modifier les fichiers _*config.xml pour autoriser l’exécution de certaines actions à un moment spécifié lors de 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 package App-V, qui est représentatif des opérations de séquencement et constitue la stratégie de choix, sauf si les 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 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.

Exemples de fichiers de configuration dynamique

L’exemple suivant montre la combinaison des fichiers Manifeste, Configuration de déploiement et 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 non pas d’être une description complète des catégories spécifiques disponibles dans chaque fichier. Pour plus d’informations, téléchargez le Guide de séquencement App-V.

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: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 pendant le séquencement et le déploiement sur le client pendant la publication d’applications virtuelles. App-V prend également en charge la capture d’assemblys côte à côte pendant le séquencement pour les assemblys qui ne sont pas présents sur l’ordinateur de séquencement. Pour les assemblys constitués de Visual C++ (version 8 et ultérieure) ou d’exécution MSXML, Sequencer détecte et capture automatiquement ces dépendances, même si elles n’ont pas été installées pendant la surveillance.

La fonctionnalité d’assemblys côte à côte supprime les limitations des versions précédentes d’App-V, où App-V Sequencer ne capture pas les assemblys déjà présents sur la station de travail de séquencement, et privatise les assemblys, ce qui la limite à une version bit par package. Ce comportement a entraîné le déploiement d’applications App-V sur les clients sans les assemblys côte à côte requis, ce qui a entraîné des échecs de lancement d’application. Cet échec a forcé le processus d’empaquetage à documenter et à s’assurer que tous les assemblys requis pour les packages étaient installés localement sur le système d’exploitation client de l’utilisateur. Cette tâche était à la fois un défi de gestion et d’implémentation en raison du nombre d’assemblys et de l’absence de documentation d’application pour les dépendances requises.

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

• Captures automatiques de l’assembly côte à côte pendant le séquencement, que l’assembly ait été ou non déjà installé sur la station de travail de séquencement.
• Le client App-V installe automatiquement les assemblys côte à côte requis sur l’ordinateur client au moment de la publication s’ils ne sont pas déjà installés.
• Sequencer signale la dépendance d’exécution vc dans le mécanisme de création de rapports Sequencer.
• Sequencer permet de ne pas empaqueter les assemblys déjà installés sur Sequencer, ce qui prend en charge les scénarios où les assemblys ont déjà été installés sur les ordinateurs cibles.

Publication automatique d’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 case activée la présence de l’assembly sur l’ordinateur. S’il ne détecte pas d’assembly, le client déploie l’assembly sur l’ordinateur. Les packages qui font partie de groupes de connexions s’appuient sur les installations d’assembly côte à côte dans les packages de base, car les groupes de connexions ne contiennent 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 des informations dans le journal des événements Windows au 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.

Trois catégories d’événements spécifiques sont enregistrées :

• Administration journalise les événements pour les configurations appliquées au client App-V et contient également les principaux avertissements et erreurs.
• Les journaux opérationnels de l’exécution générale d’App-V et de l’utilisation de composants individuels, en créant un journal d’audit des opérations App-V terminées du client App-V.
• L’application virtuelle journalise les lancements d’applications virtuelles et l’utilisation des sous-systèmes de virtualisation.