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 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 |
|
.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 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 pour 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. |
Pour plus d’informations sur le séquencement, consultez Le Guide de séquencement d’Application Virtualization.
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 de l’application virtualisée capturé pendant le séquencement. |
[Content_Types].xml |
Fichier XML |
Liste des principaux types de contenu dans le fichier appv (e.g. 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 (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 .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 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 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 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 |
Des détails supplémentaires pour le tableau sont fournis dans 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 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. Pour plus d’informations sur le mode de magasin de contenu partagé, consultez https://go.microsoft.com/fwlink/p/?LinkId=392750.
Note 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 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 d’utilisateurs stocke des 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
Description |
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 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 |
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 |
|
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 spécifique du package mentionné ci-dessus :
|
Fichiers supplémentaires dans le catalogue d’ordinateurs lorsque le package fait partie d’un groupe de connexions |
|
Catalogue utilisateur
Description |
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 étant liés à un utilisateur, et non à un ordinateur, ils doivent être itinérants avec l’utilisateur une fois qu’ils sont approvisionnés. |
Emplacement de stockage par défaut |
|
Fichiers dans le catalogue utilisateur |
|
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 :
|
Fichier supplémentaire dans le catalogue d’ordinateurs lorsque le package fait partie d’un groupe de connexions |
|
Sauvegardes de raccourcis
Pendant le processus de publication, le client App-V sauvegarde tous les raccourcis et les 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, 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 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 local COW 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). 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, une 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 de 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 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. 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, 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, si aucune donnée n’est présente 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 :
Localisation |
Description |
VACHE |
|
Package |
|
Natif |
|
Groupe de connexions VReg :
Localisation |
Description |
VACHE |
|
Package |
|
Natif |
|
Il existe deux emplacements COW pour HKLM ; processus avec élévation de privilèges et sans élévation de privilèges. 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
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é 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 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 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 des clés directes supplémentaires.
Comportement du magasin de packages App-V
App-V 5 gère le magasin de packages, qui est l’emplacement où 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 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 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 à 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 |
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 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 aient été 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.
Pour plus d’informations sur la diffusion en continu de package App-V, consultez : https://go.microsoft.com/fwlink/?LinkId=392770.
Le séquencement pour l’optimisation du streaming est disponible à l’adresse : https://go.microsoft.com/fwlink/?LinkId=392771.
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 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.
Note 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 :
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 :
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 résultantes sont stockées à l’emplacement suivant :
|
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 présente 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<strong>Local\Microsoft\AppV\Client\VFS< ; GUID>\ProgramFilesX86 |
SystemX86 |
C :\users\jsmith\AppData<strong>Local\Microsoft\AppV\Client\VFS< ; GUID>\SystemX86 |
Windows |
C :\users\jsmith\AppData<strong>Local\Microsoft\AppV\Client\VFS< ; GUID>\Windows |
appv_ROOT |
C :\users\jsmith\AppData<strong>Local\Microsoft\AppV\Client\VFS< ; GUID>\appv_ROOT |
Appdata |
C :\users\jsmith\AppData<strong>Roaming\Microsoft\AppV\Client\VFS< ; GUID>\AppData |
Le tableau suivant présente 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\jsmith\AppData<strong>Local\Microsoft\AppV\Client\VFS< ; GUID>\ProgramFilesX86 |
SystemX86 |
C :\users\jsmith\AppData<strong>Local\Microsoft\AppV\Client\VFS< ; GUID>\SystemX86 |
Windows |
C :\users\jsmith\AppData<strong>Local\Microsoft\AppV\Client\VFS< ; GUID>\Windows |
appv_ROOT |
C :\users\jsmith\AppData<strong>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 :
Lors du démarrage de l’environnement virtuel ou de la publication, le client App-V détecte l’emplacement du répertoire AppData.
Si le chemin d’accès AppData itinérant est local ou si l’emplacement Ino AppData\Roaming est mappé, rien ne se produit.
Si le chemin d’accès 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 :
L’application App-V est arrêtée, ce qui arrête l’environnement virtuel.
Le cache local de l’emplacement AppData itinérant est compressé et stocké dans un fichier ZIP.
Un horodatage à la fin du processus d’empaquetage ZIP est utilisé pour nommer le fichier.
L’horodatage est enregistré dans le Registre : HKEY_CURRENT_USER\Software\Microsoft\AppV\Client\Packages\<GUID>\AppDataTime comme dernier horodatage AppData connu.
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 lance 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 :
L’utilisateur démarre l’environnement virtuel en démarrant une application.
L’environnement virtuel de l’application recherche le fichier ZIP horodaté le plus récent, le cas échéant.
Le Registre est vérifié pour le dernier horodatage téléchargé connu, le cas échéant.
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.
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.
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.
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 :
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.
Mapper les cibles de chemin d’accès AppData itinérantes non locales sont recréées les emplacements AppData locaux et itinérants attendus.
Supprimez 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 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.
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 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, etc., 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 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’applications et non une technologie de planification des tâches, le planificateur de tâches Windows est utilisé pour activer le processus à l’ouverture de session de l’utilisateur, au démarrage de la machine et à des intervalles planifiés. La configuration du client pendant l’installation répertoriée ci-dessus 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. Les rubriques sont les suivantes :
Ajout d’un package App-V
Publication d’un package App-V
Ajout d’un package App-V
L’ajout d’un package App-V au client est la première étape du processus d’actualisation de 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 fichier appv. Ensuite, le contenu du fichier appv est développé et placé sur le système d’exploitation local aux emplacements appropriés. Voici 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
Initiation manuelle via PowerShell ou initiation de séquence de tâches du processus d’actualisation de la publication.
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.
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 des requêtes supplémentaires au serveur pour plus d’informations sur une base par package.
L’agent de publication sur le client App-V effectue toutes les actions ci-dessous sérialisées.
É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.
Configurez les packages en identifiant des opérations d’ajout ou de mise à jour.
Le client App-V utilise l’API AppX à partir de Windows et accède au fichier appv à partir du serveur de publication.
Le fichier de package est ouvert et les AppXManifest.xml et StreamMap.xml sont téléchargés dans le magasin de packages.
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.
Remplissez le magasin de packages :
Créez des fichiers partiellement alloués sur le disque qui représentent le package extrait pour tous les répertoires répertoriés.
Phasez 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.
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é).
Créer l’emplacement du magasin de packages dans le registre HKLM\Software\Microsoft\AppV\Client\Packages\PkgGUID\Versions\VerGUID\Catalog
Créez le fichier Registry.dat à partir du magasin de packages dans %ProgramData%\Microsoft\AppV\Client\VReg\{VersionGUID}.dat
Inscrire le package auprès du pilote en mode noyau App-V HKLM\Microsoft\Software\AppV\MAV
Appelez le script à partir du fichier AppxManifest.xml ou DeploymentConfig.xml pour le minutage d’ajout de package.
Configurez des groupes de connexions en ajoutant et en activant ou en désactivant.
Supprimez les objets qui ne sont pas publiés sur la cible (utilisateur ou ordinateur).
Note 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).
Appelez le montage de la charge en arrière-plan en fonction de la configuration du client.
Les packages qui ont déjà des informations de publication pour l’ordinateur ou l’utilisateur sont immédiatement restaurés.
Note 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 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. Voici les étapes détaillées.
Guide pratique pour publier et le package App-V
Les entrées de package sont ajoutées au catalogue d’utilisateurs
Packages ciblés par l’utilisateur : les UserDeploymentConfiguration.xml et les UserManifest.xml sont placés sur l’ordinateur dans le catalogue d’utilisateurs
Packages (globaux) ciblés par l’ordinateur : le UserDeploymentConfiguration.xml est placé dans le catalogue de machines
Inscrire le package auprès du pilote en mode noyau pour l’utilisateur à l’adresse HKLM\Software\Microsoft\AppV\MAV
Effectuer des tâches d’intégration.
Créez des points d’extension.
Stockez les informations de sauvegarde dans le registre et le profil itinérant de l’utilisateur (sauvegardes de raccourci).
Note Cela active les points d’extension de restauration si le package n’est pas publié.
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 très 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 ci-dessus.
Lancement de l’application
Après le processus d’actualisation de la publication, l’utilisateur lance puis relance une application App-V. Le processus est très simple et optimisé pour un lancement rapide avec un minimum de trafic réseau. Le client App-V vérifie 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
L’utilisateur lance l’application en cliquant sur un raccourci ou un appel de type de fichier.
Le client App-V vérifie l’existence dans le catalogue d’utilisateurs pour les fichiers suivants
UserDeploymentConfiguration.xml
UserManifest.xml
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.
Ensuite, le client App-V vérifie que le chemin du package inscrit pour le service client App-V se trouve dans le Registre.
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.
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.
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.
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
Le client App-V effectue une actualisation de publication et découvre une version plus récente d’un package App-V.
Les entrées de package sont ajoutées au catalogue approprié pour la nouvelle version
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
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
Inscrire le package auprès du pilote en mode noyau pour l’utilisateur à l’adresse HKLM\Software\Microsoft\AppV\MAV
Effectuer des tâches d’intégration.
- Intégrez des points d’extensions (EP) à partir des fichiers manifeste et de configuration dynamique.
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.
Les EP de version 1 existent déjà lorsqu’une nouvelle version devient disponible.
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.
Exécuter des scripts ciblés pour le minutage de publication.
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écutera ultérieurement, selon les règles suivantes :
| Type de tâche | Règle applicable |
|---|---|
Tâche basée sur l’utilisateur, par exemple, 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âche globale, par exemple, activation d’un groupe de connexions à l’échelle mondiale |
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 |
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 propre à l’ordinateur et vous pouvez l’effectuer à tout moment en effectuant les étapes décrites dans la section Ajouter un package ci-dessus. |
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. 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 en cours d’utilisation 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 Windows Explorer, l’utilisateur ne peut pas être connecté. Les utilisateurs doivent se déconnecter et se reconnecter pour lancer la mise à niveau du package App-V. |
Publication globale et publication utilisateur
Les packages App-V peuvent être publiés de l’une des deux manières suivantes : Utilisateur qui donne droit à un package App-V à un utilisateur ou à un groupe d’utilisateurs spécifique et 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, considérez 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 au démarrage du service client App-V, ce qui signifie en fait un redémarrage de la machine.
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é (périodiquement, actualisation et évaluation de la stratégie ConfigMgr, 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 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 très simple, 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éintégré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 ci-dessous :
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.
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.
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é. Cela ne lancera pas de restauration des données ou du Registre.
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. Voici la liste des points d’extension couverts 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. Lors de la publication et de l’annulation de la publication d’applications 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 à ce qui suit :
<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 spécifiquement inscrite (.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 ci-dessous :
<Extension Category="AppV.FileTypeAssociation">
<FileTypeAssociation>
<FileExtension MimeAssociation="true">
<Name>.xdp</Name>
<ProgId>AcroExch.XDPDoc</ProgId>
<ContentType>application/vnd.adobe.xdp+xml</ContentType>
</FileExtension>
<ProgId>
<Name>AcroExch.XDPDoc</Name>
<Description>Adobe Acrobat XML Data Package File</Description>
<EditFlags>65536</EditFlags>
<DefaultIcon>[{Windows}]\Installer\{AC76BA86-7AD7-1033-7B44-A94000000001}\XDPFile_8.ico</DefaultIcon>
<ShellCommands>
<DefaultCommand>Read</DefaultCommand>
<ShellCommand>
<ApplicationId>[{AppVPackageRoot}]\Reader\AcroRd32.exe</ApplicationId>
<Name>Open</Name>
<CommandLine>"[{AppVPackageRoot}]\Reader\AcroRd32.exe" "%1"</CommandLine>
</ShellCommand>
<ShellCommand>
<ApplicationId>[{AppVPackageRoot}]\Reader\AcroRd32.exe</ApplicationId>
<Name>Printto</Name>
<CommandLine>"[{AppVPackageRoot}]\Reader\AcroRd32.exe" /t "%1" "%2" "%3" "%4"</CommandLine>
</ShellCommand>
<ShellCommand>
<ApplicationId>[{AppVPackageRoot}]\Reader\AcroRd32.exe</ApplicationId>
<Name>Read</Name>
<FriendlyName>Open with Adobe Reader 9</FriendlyName>
<CommandLine>"[{AppVPackageRoot}]\Reader\AcroRd32.exe" "%1"</CommandLine>
</ShellCommand>
</ShellCommands>
</ProgId>
</FileTypeAssociation>
</Extension>
Note 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 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, de Sequencer 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 des formats de Presse-papiers supplémentaires à 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 des détails supplémentaires.
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).
Pour plus d’informations sur l’intégration d’App-V, consultez : https://go.microsoft.com/fwlink/?LinkId=392834.
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>
Note 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 ne sont pas toujours spécifiquement appelées applications virtualisées utilisant 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 clique sur un lien mailto : et s’attend à obtenir 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 d’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. Cela s’effectue généralement à partir de l’écran d’exécution ou de démarrage, en fonction du système d’exploitation, qui permet aux administrateurs de fournir l’accès aux applications App-V à partir de commandes ou de scripts du système d’exploitation sans appeler le chemin d’accès spécifique à l’exécutable. 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 : https://go.microsoft.com/fwlink/?LinkId=392835.
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 décrits ci-dessus 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 l’affichage des données du fichier pour le raccourci (%Public%\Desktop) et des 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 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
Le déploiement de packages App-V sur un ordinateur ou un utilisateur est très simple. Toutefois, à mesure que les organisations déploient des applications AppV 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 pendant le séquencement dans le fichier manifeste, mais prend également en charge la modification avec les fichiers de configuration dynamique.
La configuration dynamique App-V permet de spécifier une stratégie pour un package au niveau de l’ordinateur ou au niveau de l’utilisateur. Les fichiers de configuration dynamique permettent aux ingénieurs de séquencement de modifier la configuration d’un package, après le séquencement, pour répondre aux besoins de groupes individuels d’utilisateurs ou de machines. Dans certains cas, il peut être nécessaire d’apporter des modifications à l’application pour fournir des fonctionnalités appropriées dans l’environnement App-V. Par exemple, il peut être nécessaire d’apporter des modifications aux fichiers _*config.xml 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 package appv, 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.
Exemple de fichiers de configuration dynamique
L’exemple ci-dessous 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 d’être une description complète des catégories spécifiques disponibles dans chacun des fichiers. Pour plus d’informations, consultez le Guide de séquencement d’App-V 5 à l’adresse : https://go.microsoft.com/fwlink/?LinkID=269810
Manifeste
<appv:Extension Category="AppV.Shortcut">
<appv:Shortcut>
<appv:File>[{Common Programs}]\7-Zip\7-Zip File Manager.lnk</appv:File>
<appv:Target>[{AppVPackageRoot}]\7zFM.exe</appv:Target>
<appv:Icon>[{AppVPackageRoot}]\7zFM exe.O.ico</appv:Icon>
</appv:Shortcut>
</appv:Extension>
Configuration du déploiement
<MachineConfiguration>
<Subsystems>
<Registry>
<Include>
<Key Path= "\REGISTRY\Machine\Software\7zip">
<Value Type="REG_SZ" Name="Config" Data="1234"/>
</Key>
</Include>
</Registry>
</Subsystems>
Configuration utilisateur
<UserConfiguration>
<Subsystems>
<appv:ExtensionCategory="AppV.Shortcut">
<appv:Shortcut>
<appv:File>[{Desktop}]\7-Zip\7-Zip File Manager.lnk</appv:File>
<appv:Target>[{AppVPackageRoot}]\7zFM.exe</appv:Target>
<appv:Icon>[{AppVPackageRoot}]\7zFM exe.O.ico</appv:Icon>
</appv:Shortcut>
</appv:Extension>
</Subsystems>
<UserConfiguration>
<Subsystems>
<appv:Extension Category="AppV.Shortcut">
<appv:Shortcut>
<appv:Fìle>[{Desktop}]\7-Zip\7-Zip File Manager.lnk</appv:File>
<appv:Target>[{AppVPackageRoot}]\7zFM.exe</appv:Target>
<appv: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. Et pour les assemblys constitués de Visual C++ (version 8 et ultérieure) et/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é 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 qui se limitent à une version de 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 de l’assembly côte à côte dans App-V offre les fonctionnalités suivantes.
Captures automatiques de l’assembly SxS pendant le séquencement, que l’assembly soit déjà installé ou non 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.
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 des assemblys SxS
Lors de la publication d’un package App-V avec des assemblys SxS, le client App-V case activée 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 de groupes de connexions s’appuient sur les installations d’assembly côte à côte qui font partie des packages de base, car le groupe de connexions ne contient aucune information sur l’installation de l’assembly.
Note 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.
Note 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 décrites ci-dessous.
Administration : 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 qui ont été effectuées sur le client App-V.
Application virtuelle : journalise les lancements d’applications virtuelles et l’utilisation des sous-systèmes de virtualisation.