Professional Documents
Culture Documents
Microsoft Application Virtualization 5.1 Geekboy - Ir
Microsoft Application Virtualization 5.1 Geekboy - Ir
Application Virtualization
5.1
Ralph Jansen
Quadratura ICT
Microsoft Application Virtualization 5.1
Copyright 2015 Quadratura ICT
All rights reserved. No part of this book may be reproduced, stored in a retrieval system,
or transmitted in any form or by any means, without the prior written permission of the
publisher, except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the
information presented. However, the information contained in this book is sold without
warranty, either express or implied. Neither the author, nor Quadratura ICT, and its dealers
and distributors will be held liable for any damages caused or alleged to be caused directly
or indirectly by this book.
First published: October 2015
www.packagingsupport.nl
Welcome
Introduction
Welcome to Microsoft Application Virtualization 5.1.
Warnings or important notes appear in a box like
this.
What you need for this book
To follow the tutorials in this book, you need a copy of App-V.
Download Microsoft Desktop Optimization Package (MDOP) from the
Microsoft website to access the App-V sources.
Since there is no trial version of App-V, you will need to be a Software
Assurance customer to access the Microsoft Desktop Optimization
Package sources.
Prerequisite Skills and Knowledge:
Basic knowledge of:
Microsoft Windows Server 2008 - 2012 R2
including Active Directory, File Services
Database Connectivity
Electronic Software Distribution Systems like SCCM
Application packaging, transformation and deployment
PowerShell and scripting
Concepts of Desktop Delivery Models like SBC and VDI
Acknowledgments
The task of creating any book requires the talents of many hard-working
people pulling together to meet impossible deadlines and untold stresses.
I would firstly like to thank my fantastic wife, Paula, and my two kids
Thomas and Noud, for their patience when I spend time writing this
book.
Thanks to the App-V team at Microsoft for creating such an incredible
product and the App-V MVP team for being such a welcoming and
supportive group.
It was a great experience.
Ralph Jansen
Eindhoven, Netherlands
Stay in touch
Lets keep the conversation going! I am on Twitter:
http://twitter.com/RalJans.
Contents
Welcome
Introduction
Who this book is for
Conventions and features in this book
What you need for this book
Acknowledgments
Errata & book support
Stay in touch
Contents
Chapter 1 - Introduction to App-V
What is App-V?
Components
Hardware requirements
App-V 5.1 client and sequencer
App-V 5.1 server prerequisites
File repository
Creating the database
RunVirtual
PowerShell
Command line switch /appvpid
Command line hook switch /appvve
User State Virtualization
Operating System
SSL/TLS/HTTPS
Firewall
File Security
AppLocker
Management Console
Antivirus exclusions
PackageStoreAccessControl
RequirePublishAsAdmin
Disaster Recovery
ROOT
Scripts
Copy-on-Write
Excluded extensions
Integration Points
Pass-through Keys
Dynamic Virtualization
What is App-V?
Microsoft Application Virtualization (App-V) eliminates application
installations and abstracts applications from the operating system to
prevent application conflicts. Virtual applications appear to the user just
like any other application.
It transforms applications into centrally-managed virtual services that do
not conflict with other applications. This accelerates application
deployment, upgrades, patching and retirement by eliminating time-
consuming processes and simplifying the application management
lifecycle.
App-V allows applications to be encapsulated from the underlying
operating system on which it is executed. Multiple application versions
can coexist because they are running in their own isolated environment.
This makes it possible to run multiple versions of the same application on
the same system and reducing regression and interoperability testing.
When an application is virtualized, it no longer needs a traditional local
installation. Applications are not installed but are streamed via the
corporate network to desktops, laptops, or virtual desktop environments.
Usage rights for App-V for RDS are included with the RDS Client
Access License (RDS CAL). However, the App-V Windows Desktop
client, which is installed on physical and virtual Windows desktops, is
licensed through Microsoft Desktop Optimization Pack (MDOP).
Components
Planning an App-V infrastructure to support the current user and
application base requires an understanding of the operations that will be
performed by all components in the infrastructure. The architecture of
App-V includes six primary components:
Microsoft Application Virtualization Management Server
Microsoft Application Virtualization Publishing Server
Microsoft Application Virtualization (Remote Desktop Services)
Client
Microsoft Application Virtualization Sequencer
Microsoft SQL server
Package repository
Lets start by reviewing what each component of App-V 5 represents and
understanding the role each component plays.
The Management Server is the communication conduit between the App-
V Web Management Console and the SQL Server data store. These
components can all be installed on a single server, or on one or more
separate systems depending on the required system architecture.
The App-V management infrastructure can only deploy virtual
applications and Connection Groups, deploying the App-V client or
native applications is not possible.
The App-V Publishing Server provides App-V
Clients with entitled Packages and Connection
Groups for the specific user and system.
The .AppV file uses the specifications from the AppX format, based
on the Open Packaging Conventions (OPC) standard. OPC is a
container-file technology initially created by Microsoft to store a
combination of XML and non-XML files that together form a single
entity.
A Windows Installer file (.MSI)
The MSI file automatically publish the shortcuts and File Type
Associations and loads the application into cache.
It does not contain any application files, these are in the .AppV file.
XML files
Including report.xml, <packagename>_deploymentconfig.xml, and
<packagename>_userconfig.xml.
The userconfig and deploymentconfig xml files are used to configure
custom changes to the default behavior of the package.
Package Accelerator file (.CAB)
The CAB file is the input file when using a Package Accelerator. It
includes all the information for the Microsoft Application
Virtualization Sequencer about how to build a package.
Package Accelerator file (.APPVT)
A template file that contains the modified settings in the sequencer. It
contains, for example, the changed values from the General Items and
Exclusion Items.
The APPV, XML and MSI files are created for every package. The CAB
and the APPVT file are not created by the sequencer when saving the
package but can be generated if needed.
The App-V sequencer feels and looks the same as the previous version of
App-V 5, although it has an improved GUI to improve the sequencing
experience. The improved GUI makes the sequencer easier to use than
ever before.
SQL database
A database is only a required component in an App-V Full Infrastructure
with a Management Server. The Full Infrastructure is heavily dependent
on a high performance SQL infrastructure.
App-V utilizes the SQL Server to store configuration and usage
information. It contains:
Information about Packages;
Information about Connection Groups;
Package and Connection Group assignments to users and
systems;
Who has access to the Management server;
List of Publishing server;
Optionally, reporting data.
These operations are ongoing and increase the growth of the database.
As a general guidance for the size of the database, for a 1,000 packages
you would size the App-V Management SQL database 1 GB in size.
File repository
The file repository will be used to store the App-V packages and clients
will be streaming the packages from this location to their cache. It can be
placed on a local directory, remote server, or SAN. The file repository is
crucial since clients cannot stream new packages if the file repository is
offline.
HTTP/HTTPS or file streaming (SMB) will be used to access packages
from the file repository. HTTP(S) or SMB is selected when adding
packages to the App-V Management server.
Dependent on the size of the environment and the high availability
requirements, the file repository can be setup simple or complex. The
amount of data being transferred will depend on the number of unique
packages and the size of those packages. The impacts of this remote
transfer includes increased network utilization, increased disk I/O,
memory and CPU usage on both the sending and receiving computers.
Architecture
Building an App-V infrastructure requires an understanding of the
components which make up the environment. Planning an App-V
infrastructure to support the current user and application base requires an
understanding of the operations that will be performed by all components
in the infrastructure.
The following image displays the App-V architecture and the
components.
Version 5 is a bold new release. It is different from 4.x since it now has
features that were not feasible previously, like shell extension support.
Microsoft App-V 5 looks different, very different, but everything good
about App-V has been retained for version 5 and almost everything that
was bad in version 4 has been discarded. This means you dont have to
throw away all your existing hard-earned knowledge.
Version 5 brings all manner of new enhancements in both the underlying
architecture and the interface. With an innovative new Management
Server interface, file types and Windows PowerShell support, App-V 5
can help IT deliver more while reducing costs.
Some of the most important changes are:
No dedicated drive letter required
One of the most important improvements in App-V 5 is that the Q
(or equivalent) drive isnt necessary anymore. This is something
that enterprise customers have wanted for a long time.
Database is no longer a single point of failure
In version 5 the client can still receive publishing information
even if the App-V database is unavailable.
Changes to the database, using the Management server, is not
possible when the database is unavailable.
Different file format
No RTSP(S) streaming, only HTTP(s) or SMB
App-V 5 now supports two types of streaming, HTTP(s) and
SMB. In the past, the Real-Time Streaming Protocol (RTSP) was
available.
At the moment of writing, using a SMB 3.0 file share as the
location for your packages offers the fastest streaming of virtual
applications. SMB 3.0 is introduced in Windows Server 2012.
No 4GB limit
Starting in App-V 5, a package has a much larger storage
capacity. It can now extend the 4 GB limit. This is a great feature
when you have large packages that, even with compression
enabled in version 4, use more than 4 GB of hard disk space.
Shared Content Store
Storage is a key part of any IT infrastructure. For many
organizations, storage is also a major cost center that consumes a
large portion of the budget of the IT department. Maximizing the
performance and efficiency of storage while helping to reduce
costs was a major goal of the Shared Content Store (SCS). SCS
makes it possible to stream packages into RAM and not on disk.
Saving a tremendous amount of storage. This saves costs,
especially in a hosted environment (SBC/VDI).
Virtual Application Extension
Extension Points are registered natively with Windows to allow
integration between the virtual application and the Windows
operating system. These extension points enable the application
to integrate with the local operating system.
And more
Rich PowerShell scripting for sequencer, client and server.
This allows IT to automate repetitive tasks and to integrate
App-V with existing processes;
App-V diagnostic information is in the Windows Event
Log instead of separate log files;
Web-based management makes it easy to get work from
any location.
Dynamic Suite Composition to allow two virtual
applications to talk to one another is renamed to
Connection Groups in App-V 5.
If you have been an App-V 4 user, you might be surprised to see that
some of the features are accustomed to using are no longer included in
version 5. For example, authorization for cached applications is not
available anymore nor is Enforce Security Descriptors.
Better navigation in the Management Server console
The Management Server console adds several improvements to
simplify navigation. Every console page now has its own URL,
making it easier to bookmark pages for quick access in the future.
Admin: http://ManagementServer/Admin
Servers: http://ManagementServer/Servers
Connection Groups: http://ManagementServer/ConnectionGroups
Packages: http://ManagementServer/Packages
Every package and Connection Group now has a number so it can
easily be bookmarked. For example:
http://localhost:8080/Console/Packages/Package/3006
http://localhost:8080/Console/ConnectionGroups/ConnectionGroup/1005
The Connection Groups page is now part of the main menu of
the Management Server console, at the same level as the
Packages page.
In the previous version, the Connection Groups icon was
displayed when clicking on the packages part of the menu. This
has been replaced by a separate icon in the main menu.
Optimization of the Management Server console.
You can import and export the AppxManifest.xml file in the
sequencer to make changes like removing shell extensions or
edit file types.
One of the new features of App-V sequencer is the ability to
import and export files and directories, registry keys and the
AppxManifest.XML file so modifying virtual applications is
easier than before.
This is done under the Advanced tab there is a new feature to
Enable Browser Helper Objects, if detected.
The new sequencer provides the ability to easily replace values in
the registry.
App-V 5.1 supports the use of multiple scripts on a single
event trigger for App-V packages
App-V 5.1 supports the use of multiple scripts on a single event
trigger for App-V packages, including packages that you are
converting from App-V 4.6 to App-V 5.0 or later. This setting
enables greater flexibility by the use of multiple scripts.
The single event trigger uses a script launcher application, named
ScriptRunner.exe, which is installed as part of the App-V client
installation to run multiple scripts.
You can now enable that only Administrators can publish
App-V packages
App-V 5.1 has a new option, RequirePublishAsAdmin, that
enables that only users with administrative rights can publish
applications. This offers granular control over who can publish
packages on a system.
These are just the names of some of the new and enhanced features in
App-V 5.1. With the new features, it is undoubtedly a marked
improvement over previous versions.
In short, whether youre a first timer or have been using App-V for years,
this is the strongest and most exciting version of App-V yet.
Summary
Theres a lot to like about App-V 5 and 5.1. We have now gone through
what application virtualization is, the components of App-V, what the
new features are of App-V 5.1 and took a tour through all the
components of App-V and resources that it will require. Now that we
have got a good understanding of how App-V works and what our
options are.
At this point, you are ready to start the planning phase and move forward
into the initial setup phase. This will be the focus of the next chapter.
Chapter 2 - Installation
Installing App-V infrastructure servers on your network is not something
to be done casually and you must plan the installation well in advance.
Among other things, you must decide what your deployment strategy
will be and what roles you intend to implement and combine on the
server.
This chapter details the steps necessary to implement a successful App-V
environment, using either a clean install or an upgrade, and the
configuration tasks you must perform after the installation.
Make sure that you carefully review the prerequisites because these are
important steps.
In this chapter:
Planning the installation
Creating the database
Server installation
Client installation
App-V graphical user interface application
Sequencer installation
Upgrading from App-V 4.x
Upgrading from App-V 5.0
Upgrading clients from 4.x
Hardware requirements
The following table is a guideline for the hardware requirements, as
always, it is minimal and more (virtual) hardware is recommend for a
better performing App-V infrastructure.
* It is recommended that the disk drive be at least three times as large as the largest application
that will be sequenced.
The App-V server components are not supported
on Windows Server Core or on a domain controller.
Make sure that the account that is being used to install the server
components has administrative rights on the system where you want to
install the App-V 5.1 server components. The account also must be able
to read Active Directory information.
Microsoft Application Virtualization requires you to select an Active
Directory group to use as an App-V administrators group for controlling
administrative access to the Management Console. During the setup
wizard, the name of this Active Directory group or account is asked and
will be authorized to manage App-V. This group or account must exist
prior to running the setup and must have appropriate access to the App-V
databases.
The Management and Publishing server are built on Internet Information
Services (IIS). IIS must be installed and configured prior to installing the
components.
The following IIS components are required for the Publishing, Reporting
and the Management server role:
Common HTTP Features:
Static Content
Default Document
Application Development:
ASP.NET
.NET Extensibility
ISAPI Extensions
ISAPI Filters
Security:
Windows Authentication
Request Filtering
Management Tools:
IIS Management Console
If SSL/TLS is a requirement, the appropriated (self-signed) certificates
must be available and selected within IIS.
Before starting the installation, determine what port will be used for the
Management Server, Reporting Service and the App-V Publishing
Server. Make sure to open these incoming ports in the Windows Firewall.
The App-V 5 server components use Microsoft SQL server as database
engine. When planning an App-V infrastructure, ensure that you work
closely with your SQL administrators so that you can optimize database
creation and security. The SQL server name and instance for the
Management database and Reporting database must be known before
starting the setup. If Reporting will be used, it should run on a dedicated
server since it consumes a lot of memory and CPU when generating
reports.
High availability offers a fault tolerant solution that ensures that App-V
services can be delivered without interruption. High availability of the
Publishing Server and the package content location is recommended for
both availability (for example DDoS) and failure (no disk space, etc.) of
the components.
When the Management Server is unavailable, virtual applications can
still be streamed from the package content. When the Publishing Server
or the package content is unavailable virtual applications are not
available, unless they are mounted previously on the client.
File repository
A File repository is the location where the virtualized application
packages are placed for the App-V client to retrieve them for streaming.
After an application has been virtualized, the package must be placed on
the repository that will be used to deliver the virtual application package
to clients.
Depending on the number of packages and on how often the package is
updated, there might be a higher storage requirement.
Think about the amount of storage necessary for the packages and future
growth before implementing App-V.
Creating the database
App-V needs a repository to store all information about packages,
Connection Groups, servers and so on. The supported repository is
Microsoft SQL Server. This can be SQL Server Express or SQL Server.
App-V operations will place only a very small load on the SQL Server.
See some amazing facts how much an App-V 5 infrastructure component
can support.
App-V 5 supports the following versions of Microsoft SQL Server:
Microsoft SQL Server 2008 Express
Microsoft SQL Server 2008 R2 Express
Microsoft SQL Server 2008
Microsoft SQL Server 2008 R2 SP2
Microsoft SQL Server 2012 Express
Microsoft SQL Server 2012
It depends on what level of performance and availability is needed to
choose the right version. For a small and evaluation environment, the
SQL Express edition should be the right choice. If there are a lot of
packages, users and clients or if you want to make the database high
available, you should implement the non-Express version of SQL Server.
For SQL Server, the supported versions are Standard, Enterprise,
Datacenter or the Developer Edition with the Database Engine Services
installed. App-V 5 does not allow the use of SQL Server dynamic ports
so SQL must be configured to have a static port.
App-V needs a Management database and, if desired, a Reporting
database. For a separate database installation, we need to perform the
installation operations, as explained in the following section.
The database can be createdError! Bookmark not defined. using two
methods:
1. Run the App-V installer on the SQL database server.
2. Extract the database creation scripts from the App-V installer and
run the SQL scripts on the SQL server.
Running an installer on a SQL server is usually not desirable from a
Database Administrator perspective. Option 2 is a more advanced
scenario but is granular and more DBA friendly.
The SQL scripts are included in the App-V installer and can be extracted
from here.
Creating the App-V database using SQL scripts
Before we can start editing the SQL scripts, we first need to have
the information that needs to be put into the SQL scripts.
The following information is required for the Management database:
Management SQL Server name;
Management SQL Server instance name;
Management SQL Server port;
Management database name
Management database group with read and write access;
Management database group with read access;
The following information is required for the Reporting database:
Reporting SQL Server name;
Reporting SQL Server instance name;
Reporting SQL Server port;
Reporting database name
Reporting database group with read and write access;
Reporting database group with read access;
The App-V Management server computer object,
in Active Directory, needs to be a member of the
Management read and write access group.
The App-V Reporting server computer object, in
Active Directory, needs to be a member of the
Database read and write access group.
Now that all the information is present, we can start extracting and
modifying the SQL scripts.
This guide provides a step-by-step walkthrough that enables you to
generate the SQL database scripts, which will be used later to create the
SQL database.
Extract the SQL scripts
1. Run appv_server_setup.exe /layout %temp%\appvextracted to
extract the SQL server scripts from the App-V installer.
2. Verify that the database scripts are extracted in the
appvextracted folder in the %temp% location.
Modify the Management database SQL scripts
3. Navigate to the ManagementDatabase folder
4. Edit the database.sql file and modify the database names as
necessary.
5. Edit the Permissions.sql file and provide all the necessary
account information for setting up read and write access on the
database.
Modify the Reporting database SQL scripts
6. Navigate to the ReportingDatabase folder
7. Edit the database.sql file and modify the database names as
necessary.
8. Edit the Permissions.sql file and provide all the necessary
account information for setting up read and write access on the
database.
Save the files and hand these to your SQL server administrator
or proceed to the next paragraph.
Run the SQL scripts on the SQL server
When the SQL scripts are modified with the correct values,
the scripts can be executed.
Create the Management database using the SQL scripts
9. Ensure the target SQL Server instance and SQL Server Agent
service are running.
10. Open the SQL Management Console and connect to the SQL
server where the databases will be hosted.
11. Click on File and click on Open, File
12. Select all the SQL script and click on Open
13. Execute the scripts in the following order:
Database.sql (on the Master database)
Optional: UpgradeDatabase.sql
CreateTables.sql
CreateReportingStoredProcs.sql
CreateStoredProcs.sql
CreateViews.sql
InsertVersionInfo.sql
Permissions.sql
ScheduleReportingJob.sql
Now the database and tables are created and the permissions are set.
During the App-V setup, we can use select the two databases as the
Management database and the Reporting database for App-V.
Server installation
Now that the App-V components (Management, Publishing and
Reporting) are clear and optionally the databases are in place, the setup
can be started. The section guides you through the step-by-step process
of installing the App-V Full Infrastructure.
The User Account Control dialog box can appear when you try to
perform a task that requires administrative permissions. If your account
is a member of the local Administrators group, then you can click
Continue when you are prompted. If your user account is not an
administrator, then you must provide the credentials (user name and
password) of an account that has the required permissions.
During App-V 5.0 Setup, setup log files are created
in the %temp% folder of the installing user.
Client installation
Before you can use any virtual application, you need to install the App-V
client. The installation is very straightforward and the default settings
satisfy in most environments, but a little configuration might be
necessary.
In version 5.1 the App-V client installation does not require a reboot.
For the RDS version of the client, the installation steps are the same.
In summary, sequenced packages created with previous versions of the
App-V 5 sequencer should work with the App-V 5.1 client.
On a 64-bit operating system use the 64-bit version
of the App-V client. This client supports both
packages created with a 32 and 64-bit sequencer.
Sequencing with a 64-bt Sequencer is the same
process as 32-bit sequencing.
Installing the client
To start the App-V virtualized application you need to have the App-V 5
Client on the machine.
1. Start appv_client_setup.exe
2. Click on Install
/?, /h, /help Requests help about the previous installation par
The next section gives an example how to silently install the App-V
client. Parameters that you use depend on your environment.
1. Open the Command Prompt as administrator
2. Run the command:
appv_client_setup.exe /q /NORESTART /ACCEPTEULA /CEIPOPTIN=0
/MUOPTIN=0 /AUTOLOAD=2 /ENABLEPACKAGESCRIPTS=1 /Log
%TEMP%\App-V.log
3. After the setup completes, the App-V client is installed and ready to
use.
The Work Offline button can be used to prevent updates but requires
administrative permissions on the system before it can be used.
The Virtual Application tab shows the virtual applications that are
available on the system and allows the end user to repair the package.
This will reset all the application configuration to the default values. Be
careful to use this function because it will remove all changes made by
the user.
The App Connection Groups tab displays all the Connection Groups that
are available on the system.
A feature that is less useful for end-users but is interesting for system
administrations is the Show PowerShell command. This button displays
all the PowerShell commands executed by the Microsoft Application
Virtualization 5.0 Client UI Application. This is useful to learn the
PowerShell commands that the GUI applications executes under the
hood.
Sequencer installation
Proper configuration of the sequencing station is imperative to ensure
that applications will function properly when streamed to a client.
Sequencing 64-bit applications requires sequencing
on a 64-bit operating system. The resulting
package can only be deployed to a 64-bit operating
system with the 64-bit App-V client.
Installing the App-V sequencer
If the prerequisites are in place (see planning the installation) the
sequencer can be installed.
1. Start appv_sequencer_setup.exe
2. Click on Install
3. Click on I accept the license terms and click Next
4. Choose to join the Customer Experience Improvement program and
click Install. Wait for the installation to finish.
5. Click on Close
The App-V sequencer can now be started from the start menu.
If you are using a virtual machine to create virtual applications, it is
advisable to create a checkpoint or snapshot before starting the App-V
sequencer.
Upgrade
Upgrading to version 5 is a big step and, while Microsoft makes every
effort to make it as smooth as possible, there may still be hiccups.
Always create a backup before upgrading your
App-V environment.
You can upgrade to App-V 5.1 directly from any of the previous 5.x
versions. Packages and Connection Groups will continue to work as they
currently do.
The order to upgrade the components is:
1. Microsoft Application Virtualization Server;
2. Microsoft Application Virtualization Sequencer;
3. Microsoft Application Virtualization (RDS) Client;
4. Connection Groups
Upgrading server components to 5.1
To upgrade the server components to version 5.1, follow the following
steps:
1. Start appv_server_setup.exe and click on Install.
2. Select I accept the license terms and click on Next.
3. Select User Microsoft Update when I check for updates
(recommended). Click Next.
4. In the next screen the current installed server components are
displayed and greyed out. These components will be upgrade. Click
Next.
5. Because the App-V services will be restarted, the next screen warns
you that the services will be interrupted and the system will be
restarted. Click Next.
6. The next eight screens show the current configuration and these
values cannot be changed in an upgrade scenario. In every screen
click Next.
7. When ready, click Install to begin the upgrade process.
8. Wait for the upgrade to finish. Click on Close
Thats it, the server is upgraded. Repeat the upgrade process on every
server that contains App-V server components.
Upgrading the sequencer
The sequencer cannot be upgraded by an in-place upgrade. To migrate to
the latest version, uninstall the current older version of the sequencer and
install the new version. See Sequencer installation for more information
how to install the App-V Sequencer.
Upgrading the client
Upgrading the client requires that all virtual applications will be
shut down during the upgrade. Shutting down the virtual
applications makes sure the App-V client and all its related
programs are properly closed and avoid potential problems during
the upgrade.
After the App-V client is upgraded a reboot
is required.
1. Start appv_client_setup.exe and click on Upgrade.
Note the warning that all virtual applications will be shut down
during the upgrade.
1. Select I accept the license terms and click on Next.
2. Choose to join the Customer Experience Improvement program and
click Upgrade.
Wait for the installation to finish.
3. Click on Restart Now or Restart Later to complete the installation.
Summary
We have now gone through the basics of the App-V installation covering
the planning, installation and the upgrade scenarios.
Choosing the right installation options is a process that takes time and
consideration. You should now have the ability to choose with
confidence.
So, to sum it up, this is what we did to get App-V up and running:
We planned the installation for the client and the sequencer;
Created manually created the App-V databases;
Installed the server components, the client and the sequencer;
Went through the upgrade scenarios when coming from version 4
and 5.
You should now have a working App-V environment that is fully
prepared to accept and manage virtual applications.
Theres still a lot to do to get the most out of the new App-V
infrastructure. In the next chapter, we will look more into the
configuration of the App-V components and completing the post-
installation steps. We also deep-dive into how the client works.
Chapter 3 - Configuration
Congratulations. Youve familiarized yourself with the installation and
upgrade of the App-V 5 components. Its now time to turn our attention
to a variety of administrative tasks to configure the App-V environment.
App-V can be configured with various settings. This chapter shows you
what options are available to configure App-V and how to modify these.
We are also going to take a look at how the App-V client works and
where the App-V client stores all the information necessary to provide
the user access to the virtual applications.
In this chapter:
Completing the server post installation steps
Configuring client settings using Group Policy
Configuring client settings using PowerShell
Configuring Remote Desktop client settings
How the client works
Client file and registry locations
App-V provides a number of methods to modify the client. These are:
Group Policy
PowerShell
Registry
Configuring client settings using
PowerShell
The App-V client can be configured using PowerShell and this is
extremely useful to configure the App-V client options. Although it is
easy, PowerShell is less efficient and does not guarantee consistency
when you have many computers to configure. When you have multiple
computers to manage, you can instead use a GPO, and then apply this
GPO to the computers.
Group Policy settings override local settings
configured using PowerShell.
PowerShell can find the App-V 5 PowerShell
module since the installation folder (default
C:\Program Files\Microsoft Application
Virtualization\Client) is added to the PowerShell
variable $env:PSModulePath
4. The App-V commands are now available.
Description
Option
Here are some examples how to change the options available from within
PowerShell:
EnablePublishingRefreshUI
This option enables the publishing refresh progress bar. Enabling it
makes a publishing refresh user friendly since they see the progress.
Set-AppvClientConfiguration -EnablePublishingRefreshUI $true
EnablePackageScripts
This option enables scripts that can be started from the Dynamic
Deployment configuration files.
Some packages include scripting to achieve optimal operation. Enable
package scripts during setup or post-installation, unless it is certain that
no packages will use scripts.
Set-AppvClientConfiguration EnablePackageScripts $true
Configuring client settings using the
registry
All the settings that are set by using Group Policy or PowerShell are
stored in the Registry under
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AppV
It is possible to view and modify the App-V client settings directly in the
registry.
It the next example, Package Scripts are enabled using the Registry.
1. Open Regedit with Administrative credentials. This is necessary since
we are modifying the HKEY_LOCAL_MACHINE and this counts
for everyone on the system.
2. Navigate to
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AppV\Client\Scripting
3. Edit the key EnablePackageScripts and set it to 1.
4. Click on OK.
Package scripts are not enabled.
There are many options in the registry to modify, and for some of the
more advanced feature of App-V it is even necessary to use the registry.
Always make a backup using the Export Key
feature when modifying the registry.
Caching on the local disk by the App-V Client is
disabled when using the Shared Content Store.
To enable the Shared Content Store, run the following PowerShell
command:
Set-AppvClientConfiguration SharedContentStoreMode 1
In addition to PowerShell, it also can be enabled during setup or after
installation by modifying a registry value.
Although the packages arent default cached on the disk when using the
Shared Content Store, it is possible to place (mount) packages in the
package store (cache) for highly utilized or important line-of-business
applications by running the following PowerShell command:
Mount-AppVClientPackage Name <name of the package>
PackageInstallationRoot
This location is the default location for the App-V cache. Because the
cache can be fairly large, place it on a drive with adequate storage for all
virtual applications targeted for delivery.
It is recommended to carefully plan and standardize on as many of these
settings as possible to achieve the most optimal configuration for your
specific environment.
%ProgramData%\Microsoft\AppV\Client\Catalog
Here are the package configuration files stored for packages that
are published Globally.
These are Manifest.xml, DeploymentConfiguration.xml,
UserManifest.xml, UserDeploymentConfiguration.xml.
%AppData%\Microsoft\AppV\Client\Catalog
Here are the package configuration files stored for packages that
are published to the user.
These are Manifest.xml, DeploymentConfiguration.xml,
UserManifest.xml, UserDeploymentConfiguration.xml.
%ProgramData%\Microsoft\AppV\Client\Catalog\PackageGroups
Here are the Dynamic Configuration files stored for Connection
Groups that are published.
These are PackageGroupDescriptor.xml and
UserPackageGroupDescriptor.xml.
%LocalAppData%\Microsoft\AppV\Client\Integration
Location to create symbolic links associated with the current
version of a user published package.
All virtual application extensions, for example shortcuts, will
point to this path but it contains only junction points (links) to
%PROGRAMDATA%\App-V
%AppData%\Microsoft\AppV\Client\Integration\ShortCutBackups
Existing native application data and registry (such as File Type
Associations) are backed up during publishing. This folder is the
backup location of all integration points and these are restored
when a package is unpublished.
If there are multiple applications that can handle a File Type
Association, the owner is transferred when a package is
unpublished.
%AppData%\Microsoft\AppV\Client\VFS
Location for package modifications that are written in non-
roaming locations. Also known as Copy on Write or COW
location.
This folder contains subfolder like ProgramFilesX86,
SystemX86, Windows and APPV_ROOT which do not roam
between different systems.
%LocalAppData%\Microsoft\AppV\Client\VFS
Location for package modifications that are written in roaming
locations. Also known as Copy on Write or COW location.
This folder contains subfolder like AppData which does roam
between different systems.
Locations in the registry
The following registry locations are used by the App-V client to store
information.
HKEY_LOCAL_MACHINE\Software\Microsoft\AppV\Client
Settings for the App-V client set by GPO, PowerShell or default.
HKEY_LOCAL_MACHINE\Software\Microsoft\AppV\Client\Packages
Extracted registry keys of the virtual packages. Contains a sub
key per package with the GUID of the package and below the
package GUID a version GUID key.
HKEY_LOCAL_MACHINE\Software\Microsoft\AppV\Client\Packages\Pu
Publishing servers set by GPO or PowerShell.
HKEY_LOCAL_MACHINE\Software\Microsoft\AppV\Client\Streaming\P
Information about the package(s), like
Location on hard disk
Size
Previously Used
Etc.
HKEY_LOCAL_MACHINE\Software\Microsoft\AppV\Client\MAV
Information about the package(s).
Location on hard disk
Connection Group priority
Etc.
HKEY_LOCAL_MACHINE\Software\Microsoft\AppV\Client\Integration
Backup of file types for unpublishing, ownership of file
associations.
Summary
In this chapter, youve learned about some of the different ways that we
can configure the App-V components, like Group Policy and PowerShell.
The important thing to keep in mind is that they are options, and there is
no right or wrong way to do things. Its all about making choices that
work for you.
We now know how the App-V client gets the packages and presents them
to users and where the client default stores files and registry entries.
This chapter ended with an in-depth look at how the client works.
In the next chapter, we will shift gears entirely and we will look into
creating virtual applications, Connection Groups and upgrading
packages.
Chapter 4 - Creating virtual applications
Now that the App-V components are installed and configured, everything
is ready to create, deploy and use virtual applications.
The process of packaging applications for App-V, or sequencing, is
typically the largest ongoing task in an App-V infrastructure.
To create a virtual application, or a package, you will need to use the
App-V sequencer. The sequencer is a wizard-based tool to create, update
and modify App-V packages.
Properly sequencing applications is the key to a successful App-V
implementation. As such, its important to follow Microsofts
recommended practices and be aware of the different options when
sequencing.
All applications are different and therefore every application will require
a different amount of time to sequence.
In this chapter:
What is new in the App-V sequencer version 5
Limitations
PVAD/VFS
Optimization
Sequencer workstation configuration
Best Practices
Creating virtual applications
Sequencing Add-ons and Plug-ins
Scripts
Package Accelerators
Dynamic Configuration Files
Connection Groups
Updating virtual applications
Converting virtual applications from 4.x
Virtualizing Microsoft Office
The file is part of the .AppV file and cannot be modified outside of the
sequencer, however it can be overwritten by Dynamic Configuration
files. But these live outside of the .AppV file and require additional
editing and importing.
In the App-V 5.1 sequencer, not there is an option to export the
AppxManifest file so it can be modified. Afterwards the file can be
imported in the sequencer so it will be included in the .AppV file when
the package is saved. When it is part of the .AppV file, it will be the
default settings when the package is used.
You can make changes to the manifest file, such as removing shell
extensions or editing file type associations.
2. After you make your changes, click Import and select the file you
edited.
3. After you successfully import it back in, the manifest file is
immediately updated within the package editor.
When you import the file, your changes are
validated against the XML schema. If the file is
not valid, you will receive an error. Be aware that
it is possible to import a file that is validated
against the XML schema, but that might still fail
to run for other reasons.
You can import and export the registry keys.
This makes it easy to import or export a large set of keys into or from the
package.
The Add File feature got a new location, it is now
located under Packager Files tab, View, Virtual File
System > Add File
Internet Explorer is not supported in a
sequenced application.
However you can sequence plug-ins or
ActiveX controls for Internet Explorer.
Applications that use COM+
The App-V sequencer cannot virtualize COM+ objects because
these are dynamic and happen at runtime. The package can be
created but may not function as expected.
It is possible to export the COM+ component to an MSI file and
deploy it to the native operating system.
COM DLL surrogate virtualization
COM DLL surrogate is a method where code is run in another
process so when it crashes the COM Surrogate process crashes
and not the main process. Applications that use COM DLL
surrogate virtualization (DLLhost.exe) cannot be virtualized.
PVAD / VFS
PVAD stands for Primary Virtual Application Directory. In previous
versions of App-V you needed to enter the PVAD in the sequencing
wizard, so the sequencer knew where the program files of the package
reside. In the latest version of App-V, the PVAD isnt a part of the
sequencing wizard anymore. Although you do not need to specify the
PVAD, in the background the App-V sequencer creates a dummy PVAD
folder in the root of C:.
VFS stands for Virtual File System these are all the files and folders that
are captured during sequencing but are outside the PVAD directory.
Microsoft changed their vision that an application needs to be installed in
the PVAD. Since the PVAD dummy folder will be generated
automatically, the application you install will be placed in the VFS.
Some applications do not work when they are installed in the VFS and
require to be installed in the PVAD. There are multiple ways to re-enable
the PVAD so it becomes available in the sequencing wizard.
Re-enabling the PVAD from the registry
Using this method, the PVAD is enabled every time you start the
sequencer.
1. On the sequencer machine, open Regedit
2. Create Navigate to
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AppVSequencer
3. Create a key Compatibility
4. Create a DWORD Value named EnablePVADControl
5. Set the value of EnablePVADControl to 1.
6. Start the sequencer and check if the PVAD is re-enabled.
Re-enabling the PVAD from the command line
1. Open the Command Prompt and navigate to the folder where
sequencer.exe exist in.
2. Add the parameter EnablePVADControl to the sequencer.exe
command line.
3. Start the wizard and check if the PVAD is re-enabled.
Optimization
In App-V 5 there are three options to optimize the packages for
streaming to the client.
Full Download
Feature Block
Fault Streaming
Full download
By using the full download option, the package is completely
downloaded into the App-V Client cache before the application is
launched. Using this option, it takes the most time before the end user
can start using their application. This option is recommended for slow or
WAN links.
One of the problems that could occur is that mobile workers who are not
always connected to the App-V infrastructure could attempt to use a
feature of a virtualized application that has not already been downloaded
into cache. This would result in an error for the user and the inability to
use the specific feature. Administrators should make sure that virtualized
application are delivered to the client cache when needed.
Feature Block
Feature blocks are designed to optimize the applications for streaming. A
Feature Block makes it possible to specify which part of the package
needs to be streamed to the client first before the application is launched.
The rest of the packaged will be streamed later when the application is
started.
The creation of a Feature Block would be implemented during
sequencing and is often done to reduce the time that the user waits for the
initial launch of the application. This enables users access to applications
more quickly upon deployment.
There are two feature blocks available.
1. Feature Block 0
FB1 can be used to optimize the user experience since the application
does not need to be fully downloaded into the cache before it
becomes visible.
Any pieces of the package not included FB1 or FB2 will be streamed by
the App-V client on-demand.
Fault Streaming
Fault Streaming only transfers new bits into the cache when the package
needs them. This offers the best user experience as the application will
have a quick first launch. But not all applications can handle this.
In the sequencer it is possible to set what package optimization will be
used. In the sequencing wizard, you must select Customize, in the
Streaming window it is possible to configure the streaming option will be
used.
Autoload
Through configuration of the AutoLoad an administrator can ensure that
the virtual application is delivered to the client cache when needed.
The following options are available for AutoLoad:
Automatically load nothing into cache;
Means applications will never be loaded automatically in the
cache. Only while they are actually in use.
Load the content of packages that have been executed at least
once on the machine (default);
See silently installing the client or
AutoLoad for more information how to
configure AutoLoad.
Best Practices
When sequencing an application, it is good to apply the following Best
Practices from Microsoft. Here are some examples from the Best
Practices for Sequencing document (http://go.microsoft.com/fwlink/?
LinkId=269953)
Familiarize yourself with the installation and execution of the
application prior to sequencing so that you learn how the
application runs and the components of the application you will
need;
Document step by step the installation and post-configuration
procedures for the application. This document is often called a
Recipe and contains all the steps taken to create the virtual
application;
Sequence with the same UAC setting that will be deployed to user
desktops;
Disable Auto Update features;
Disable Install on First Use.
At the moment of writing, the Best Practices for Sequencing document
describes using the PVAD for the installation of applications. This is not
the best practice anymore since the PVAD is now default hidden in the
sequencer and the VFS is used as default installation location.
Select the setup file by using the Browse button or select Perform
a custom installation and click Next to proceed.
8. Enter the Virtual Application Package Name, for example
PSpad_10.0_EN_V1 and click Next.
Select the operating systems from the list or select Allow the
package to run on any operating system.
Click Next.
16. When the Streaming and Target OS steps are completed, it is also
possible to add or remove files / registry keys / shortcuts, change
services etc. or to save the package or (optionally) enter a
description and save the package.
In this example, we are going to choose Continue to modify
package without saving using the package editor.
The Package Version will be set to 1 when the package is saved. The
Package GUID is the unique identifier for the package and does not
change. The Version GUID is generated when the package is saved and is
changed when the package is opened for upgrade.
The Primary Virtual Application Directory (PVAD) is the folder that is
created automatically by the sequencer. It is best practice to install the
application in the Virtual File System (VFS) unless the application does
not work. See also the chapter about PVAD/VFS.
The Deployment tab can be used to limit on what operating system the
application can be started. It is possible, for example, to limit the virtual
application to Windows 2012 R2 or 32-bits operating systems.
The Change History is grayed out until the package is opened for
upgrade. It displays information about the virtual application.
Using the Virtual Registry tab, the registry keys that are created or
modified during the monitoring phase are displayed. Here it is possible to
add, import, edit or remove registry keys.
The Package Files tab displays all the files and folders that were created
or modified during the monitoring phase. Files and folders can be added,
exported, removed. If there is a conflict with a file or folder on the local
disk, right click the file/folder and select Override Local Directory or
Merge with Local Directory.
For example, Program Files is set to Merge since this directory is always
available on every system. Folders that are created by the application that
is virtualized, are set to override since the local folder must be
overwritten by the virtual application otherwise there will be different
behavior per package per system.
When Virtual Services are detected, they will become visible in the
Virtual Service tab. These cannot be modified since this is a read only
field. If you want to modify a virtual server, for example to set the startup
type, you must do this during the monitoring phase.
The Advanced tab contains more and more features in every release of
App-V. In 5.1 the following options are on the Advanced tab:
Allow all named objects to interact with the local system
Enabling this checkbox will disable isolation of named
objects. Check this box if a virtual application and a local
application will need to communicate with each other.
Allow all COM object to interact with the local system;
Makes COM objects from virtual environment visible to
the real OS and set <COM Mode=Integrated> in the
Dynamic Configuration file. COM is responsible for
communication channels and interactions between
applications.
Allow virtual applications full write permission in the virtual file
system
If you check this option, the package will gain Write
Access to VFS Locations.
Prior to the introduction of this feature, applications that
need this would fail due to an access denied event when
the application attempts to create a file in the VFS. See
PVAD/VFS for more information about PVAD/VFS.
Enable Browser Helper Objects
Browser Helper Objects are plugins for Microsofts
Internet Explorer to provide additional functionality. For
example, the Adobe Acrobat plug-in that allows Internet
Explorer users to read PDF files within their browser.
Unattended sequencing
The Sequencer comes with a PowerShell command to allow unattended
sequencing. It offers the same functionality as the wizard of the
sequencer but does not offer the same flexibility for modifying a
package. Sequencing an application using the GUI offers more flexibility
than using PowerShell since the latter does not support:
The usage of Feature Blocks
Removing or modifying shortcuts
Enabling Advanced options
Adding or removing registry entries
Adding or removing file and folders
Modifying applications first-run. For example, disabling welcome
screens.
Since this module isnt loaded by default. It must be imported in an
elevated PowerShell window using Import-Module AppVSequencer.
The following commands are available in the AppVSequencer module:
Expand-AppvSequencerPackage
This command will expand all the files from an App-V package
to the local system and the registry. Using this command it is
possible to convert the package from virtual to native.
New-AppvPackageAccelerator
Can be used to create a Package Accelerator using a silent
installation since the sequencer know which file and registry keys
are created.
New-AppvSequencerPackage
Select the setup file by using the Browse button or select Perform a
custom installation and click Next to proceed.
7. Before sequencing the add-on or plug-in, the application where the
add-on or plug-in needs to be integrated into needs to be available on
the system where the sequence is created.
For example, if you want to sequence a plug-in for Notepad++, the
Notepad++ application needs to be on the system where the plugin
will be installed on.
In the Install Primary step, the application can be installed and will
not be part of the virtual application package.
If the primary application is a virtual application, it must be
expanded on the system. Use the Expand Package button to open the
Expand package to disk window, select the .AppV file and wait for
the extraction to complete. This can take a while depending on the
size of the App-V package.
Once the primary application is installed or extracted, check I have
installed the primary parent program and click Next.
For example, if there are any drivers installed during the installation
of the application, there will be a notification that these will not be
included in the package.
Review the issues, if any, and make sure that there are no issues
before clicking Next.
5. Select Add-on or Plug-in and click Next.
6. In the Select Installer phase, it is possible to browse to the setup file
of the application that is going to be virtualized. This is an optional
step; it is also possible to start the installer manually when the
Installation step is started.
Select the setup file by using the Browse button or select Perform a
custom installation and click Next to proceed.
7. Before sequencing the plug-in, the application where the plug-in
needs to be integrated into needs to be available on the system where
the sequence is created.
Since we are going to sequence a plug-in for Internet Explorer the
Primary parent application is already available on the system.
Check I have installed the primary parent program and click Next.
Be careful when modifying XML files because
XML files are case sensitive.
Scripts
Using the sequencer, it is possible to add scripts. Scripts can be for
example PowerShell, Visual Basic or CMD files.
System AddPackage O O
System RemovePackage O O
System PublishPackage O
System UnpublishPackage O
User PublishPackage O
User UnpublishPackage O
User StartVirtualEnvironment O O
User TerminateVirtualEnvironment O
User StartProcess O O
User ExitProcess O
Remember that you must have Administrative privileges and the option
must not be set to 0 by Group Policy because this will override the value.
1. Open the <packagename>_deploymentconfig.xml or open the
<packagename>_userconfig.xml depending on if the package will be
published globally or per user.
2. Nearly at the bottom of the file, above <MachineScripts> remove the
<!character.
3. Remove > under </MachineScripts>
4. Determine on what trigger the script must be executed, for example
PublishPackage or AddPackage
5. Between <Path> </Path> enter ScriptRunner.exe
6. Between <Arguments> </Arguments> enter appvscript and the
location of the scripts. For example:
-appvscript C:\Script1.cmd -appvscript C:\Script2.cmd
7. Remove all the other sections that contain dummy information by
selecting them. For example, remove:
Tokens
Scripts can be added to the Dynamic Configuration files and this makes it
easy to modify a package without opening it.
For example, the following can be added to create a registry key in the
virtual registry:
<Registry Enabled=true>
< Include>
< Key Path=\REGISTRY\USER\[{AppVCurrentUserSID}]\Software\
[{AppVComputerName}]\Adobe>
< Value Type=REG_SZ Name=License Data=Number/>
< /Key>
< Key Path=\REGISTRY\USER\[{AppVCurrentUserSID}]\Software\
[{AppVComputerName}]\Adobe/>
< /Include>
< /Registry>
Package Accelerators
Now that we have spent a lot of time creating our package, lets take look
at how we can speed up this process by taking advantage of a Package
Accelerators.
This is a feature that isnt very well known but it can save you time when
you have packages that need to be created repeatedly.
After a package has been sequenced, a Package Accelerator can be
created for that package. A Package Accelerator is a CAB file that
contains all the information how a package is build using the sequencer.
It does not contain the files from the application itself. Since a Package
Accelerator doesnt contain any files from the application, it is a pre-
requisite that the application is already installed on the machine prior to
building the virtual application by using a Package Accelerator. As our
goal is to speed up the packaging process it is recommended to also
create a script to install the application unattended on the sequencer.
The first step in creating a Package Accelerator is to build a package as
described in Creating Virtual Applications. When the package is saved, a
Package Accelerator can be created. This Package Accelerator can then
be used when building a new package.
Creating a Package Accelerator
1. When you have saved your virtual application, leave the sequencer
open.
2. Click on Tools, Create Accelerator
3. In the wizard, click on Browse and navigate to the .APPV file of the
package. Click Next.
Now you can choose to get the original files from the installation
directory or use files extracted from the .APPV file.
4. Since the bits are still available from the installation, choose Files
installed on local system. Click on Browse and navigate to the
location on the disk where the original files reside. Click on Select
Folder. Click on Next.
The sequencer will create the Package Accelerator.
The sequencer is often reverted to a clean state
using a checkpoint or snapshot. Make sure the
CAB file is saved when reverting to a clean state.
Now that the Package Accelerator is created, the CAB file can be used to
easily build the same package.
Using a Package Accelerator to create a Virtual Application Package.
1. Install the application that needs to be virtualized on the sequencer
machine
2. Open the App-V Sequencer
3. Click on Create a new Virtual Application Package
4. Choose Create Package using a Package Accelerator. Click on Next.
5. Click on Browse and select the CAB file from the Package
Accelerator that we created earlier. Click on Next.
There will be a pop-up that the Package Accelerator file isnt secure.
Click on Run to continue.
6. The content from the guidance file will be displayed. Review the text
and click on Next.
7. Click Browse and select the folder where the application is installed.
Click Next.
8. Review the Description and the Virtual Application Package Name
and click on Create
To apply the template, start the sequencer and click on File, Load
Template.
Connection Groups
Virtual applications do not have visibility of one another. This is a great
benefit of Application Virtualization since this enables to run multiple
versions of applications on the same system. The other major benefit of
this is it allows you to update packages separately.
Although virtual applications run in their own bubble, there is an
option for you to connect virtual environments using Connection Groups.
Connection Groups in App-V enables virtual applications to interact with
other applications, middleware or plug-ins that have been virtualized in
separate virtual application packages by sharing a common virtual
environment. This enables the application to interact with the other
virtual environment, where normally this is prevented, so a Connection
Group is a group of App-V packages which allow visibility of one
another.
Connection Groups can be made using the Management Console,
PowerShell or with System Center Configuration Manager (SCCM).
When using SCCM, optional packages are not available at the time of
writing. Optional packages will be explained later in this section.
In every Connection Group you have to specify the priority of the
applications, which should be the primary applications, which is
secondary etc. When an application in a Connection Group modifies the
same file or registry values on a system, the application with the highest
priority will take precedence.
Since App-V SP3 it is possible to create a Connection Group and specify
Optional packages. This makes it easy to assign a Connection Group that
contains packages that they are and arent entitled to, to a group of users.
Creating a Connection Group within the Management console
1. Open the Management console
2. Click on Connection Groups in the left pane of the Management
console
3. Click on Add Connection Group
4. Give the Connection Group a name and click on Add
5. Click on the create Connection Group
6. Next to Connected Packages, click on Edit
7. Select the packages that need to be part of the Connection Group
8. Click on the arrow to move the selected packages to the left
9. Change the Load Order to specify which package takes precedence
over the other package in case of a conflict.
10. Select the Use any version
This makes it possible to update the members of the Connection
Group automatically when deploying a new version of a package
11. It might be that the users do not have access to all packages in the
Connection Group. You can enable Optional to only assign the
package to the users that are entitled to use it.
12. Select Add Package Access to Group Access to assign the Active
Directory groups, which are assigned to the packages in the
Connection Group, to the Connection Group itself.
13. Click on Save
14. Click on the name of the Connection Group in the top to return to the
Connection Group properties.
15. Verify that the Active Directory access is correct.
16. Click on Publish
Creating, adding and enabling a Connection Group with PowerShell
Using PowerShell, it is possible to add a Connection Group by using an
XML file. The first step is to add all packages that need to be part of the
Connection Group, then the connection between the package can be
established by using the XML file.
See Adding packages to the system using
PowerShell how to add packages to the system.
Now that the packages that will be part of the Connection Group are
added to the system, the XML file that contains the Connection Group
information, needs to be created.
1. Open PowerShell
2. Run the command:
Get-AppVClientPackage All
3. All the packages that are available on the system become visible.
4. Find the PackageId, VersionId and Name of all the packages that need
to become part of the Connection Group.
5. Open a text editor and enter the following XML code. Change the
values:
10. The Connection Group is added and enabled for the system (Global).
Using PowerShell to add a Connection Group with Optional Packages
Prior to App-V 5 SP3, a Connection Group could only contain packages
that the user or system was entitled to use. This wasnt very flexible
because this led to a sprawl of Connection Groups enabled for groups of
users.
For example, if you have a Connection Group that contains all your
Excel plug-ins and assign it to a group of users, only the plug-ins that the
user or system is entitled to use will become visible in Excel.
When building a Connection Group with optional packages, there need to
be at least one package where IsOptional=false. These packages are
non-optional packages and these must be available at the system prior to
adding the Connection Group.
If you add packages to a Connection Group, you have to think about how
the packages are published on the system where the Connection Group
will be added. Since user published Connection Groups can contain
packages that are published globally or to the user, but globally published
Connection Groups must contain only globally published packages.
Using the following steps, it is possible to create a Connection Group
XML file with optional packages and enable it for a user or system.
The first step is to add all packages that need to be part of the Connection
Group.
See Adding packages to the system using
PowerShell how to add packages.
Now that the packages that will be part of the Connection Group are
added to the system, the XML file that contains the Connection Group
information, needs to be created.
1. Open PowerShell
2. Run the command:
Get-AppVClientPackage All
3. All the packages on the system become visible
4. Find the PackageId, VersionId and Name of all the packages that need
to become part of the Connection Group.
5. Open a text editor and enter the following XML code and changes the
values. Also change the value of IsOptional to True or False.
8. Now the Connection Group is added to the system but it is not
enabled to a user or system.
10. The Connection Group is added and enabled for the system.
When the package UltraCompare_Professional_7.10.0.1013 or
Excel_Plug-in_2.10 is available on the system and the user or system is
entitled to use it, it will be part of the connection group and the packages
can see each others virtual environments.
If UltraCompare_Professional_7.10.0.1013 or Excel_Plug-in_2.10 arent
available or the user or system is not entitled to use them, the other
packages still can see each others virtual environment.
Creating Connection Groups or Virtual Environments in System Center
Configuration Manager
In SCCM, Connections Groups are called Virtual Environments. The
Virtual Environments do not offer the same options as Connection
Groups in the App-V Management console. For example, optional
packages are not available at the time of writing.
1. Open the SCCM Management console
2. Click on Software Library
3. Expand Application Management
4. Click on App-V Virtual Environments
5. In the ribbon at the top, click Create Virtual Environment
6. Enter a name and description of the Virtual Environment
7. Click on Add
8. Enter a group name and click on Add
9. Click on the packages that need to be part of the Virtual Environment
and select the correct package from the list.
10. Click three times on Ok
The Virtual Environment will be available when a virtual application,
that is part of the Virtual Environment, is deployed to a system.
New conversion options in App-V 5.1:
You can now use the package converter to convert App-V 4.6
packages that contain scripts, and registry information and scripts.
You can now choose to add information from a subset of the .osd
files in the source directory to the package using the
OSDsToIncludeInPackage parameter.
These two new conversion options can give you a higher success rate
when converting your applications to the new format.
Testing the conversion success
The App-V converter module contains a command, Test-
AppvLegacyPackage, that can be used to test the App-V 4 package
quality before converting it to version 5. This gives an insight how many
packages will be successfully converted.
1. Copy your App-V 4.x package to the App-V 5.1 sequencer system.
2. Open PowerShell as administrator
3. Run the command: Import-Module AppVPkgConverter
4. Run the command: Test-AppvLegacyPackage <PackageLocation>
For example:
Test-AppvLegacyPackage C:\AppV4\MINDMANAGER_6_0_EN_V1
When the check is completed, it will give a report if the package can
be converted successfully. When the package has no major errors or
warnings then its a good candidate for package conversion.
However, some errors can go undetected.
Converting a 4.x package to App-V 5
When the App-V 4 packages are tested and contain no errors, the next
step is to convert them to version 5 using the conversion tool.
Conversion requires free disk space on the sequencer that is equivalent to
the size of the current package.
You can use the following procedures to convert an existing App-V 4
package to the new format in App-V 5.
1. To perform a conversion, copy your App-V 4.x package to the App-V
5.1 sequencer system.
2. Create a folder where the converted packaged will be saved.
3. Open PowerShell as administrator
4. Run the command: Import-Module AppVPkgConverter
5. Run the command:
For example:
ConvertFrom-AppvLegacyPackage -SourcePath C:\AppV4\WAPAST12.E01
-DestinationPath C:\AppV5\WAPAST12.E01 DownloadFullPackageOnFirstLaunch
6. Now wait for the conversion to finish and review the Errors,
Warnings and Informational sections.
7. When the conversion is completed, the converted package is saved in
the destination path. You should always verify package functionality
when the conversion is completed.
3. Start the downloaded setup and wait for the Getting things ready
screen to finish.
Do not disconnect from the internet since the
installation will stream Office 365 from the internet
on your local system.
4. When the setup is complete, Office is available from the start menu.
You cannot use the App-V Sequencer to create or
modify an Office 2013 App-V package.
When the Office package is converted, it is ready for deployment. It can
be deployed in the same manner as any other App-V packages that are
created by using the sequencer.
When deploying the virtual Office 2013 package, there are requirements:
Only one Office package is allowed on each client;
The Office package must be published Globally for the extension
points to function. Extension points are Shortcuts, File-Type
associations, URL Protocols, AppPaths, Software Clients (Send
to Mail, Default Program), Environment Variables and COM;
Scripting must be enabled for the App-V client to publish Office
2013 packages successfully;
To verify the status of the Office 365 subscription, systems must
have internet access every 30 days;
Users must be local administrators on their systems to install
Click-to-Run.
The user and computer settings for Office can still be configured using
Group Policy
Creating an Office 2013 package using the Office Deployment Tool
Make sure that the .NET Framework 4 is installed on the computer that is
being used to create the package. You need to create the App-V package
of Office 2013 on a computer running the 64-bit version of Windows.
Although Windows is 64 bit, the package will also work on 32-bit
computers.
1. Download the Office Deployment Toolkit for Click-to-Run from the
Microsoft Download Center. http://www.microsoft.com/en-
us/download/details.aspx?id=36778
2. After the download is complete, start the setup and extract the files
3. Navigate to the extracted files and, in a text editor, open the file
Configuration.XML
4. Remove both <! and > and change the \Server\Share\ location to
a network share where Office 2013 will be placed when it is
downloaded.
Optional: Change the 32 value to 64 to use the 64-bit version of
Office.
5. The Product ID value can be modified to include Visio and/or
Project. You can specify O365ProPlusRetail, ProPlusVolume,
VisioProRetail, and ProjectProRetail.
14. When the conversion is complete, the App-V package is generated
and can be used for deployment.
Enabling Office plug-ins
Since you cannot virtualize Office 2013 using the App-V sequencer,
plug-ins cannot be included in the Office 2013 package and need to be a
separate package that only contains the plug-in. This separate package
can then be linked to the Office 2013 package using Connection Groups.
When virtualizing the plug-in, make sure the following requirements are
in place:
Office 2013 must be installed;
Make sure that COM Mode is set to Integrated in the Dynamic
Deployment file of the plug-in package. This will enable COM to
integrate with the local system;
Make sure that InProcessEnabled and OutOfProcessEnabled is
set to True in the DeploymentConfig file of the plug-in package.
Make sure that the Dynamic Deployment file is used when
deploying the package of the plug-in.
When the plugin is created, it can be included in a Connection Group
together with the Office 2013 package.
See Creating a Connection Group within the Management console how
to do this.
Summary
This chapter covered all aspects of the creation of virtual applications
using the sequencer, the PVAD/VFS and what limitations the sequencer
has. You learned how to optimize packages and use package accelerators
to quickly create a new package.
Then Add-ons/Plug-ins, Dynamic Configurations Files and scripts were
examined. Connection Groups were explained and converting packages
was touched upon. You saw how to perform the virtualization of Office
2013 using Click-to-Run.
We can turn our attention to delivering our virtual applications to our
users and start looking at the lifecycle of these virtual application and
how to save changes the user makes to their applications.
Chapter 5 - Package Deployment
Virtual applications go through a lifecycle of sequencing, adding,
publishing, launching, upgrading, and removal. This chapter focuses on
choosing the right delivery method or methods for the virtual
applications in your environment and to your managed devices.
In this chapter:
Choosing the right delivery method
Deployment using PowerShell
Deployment using the Full Infrastructure
Deployment using System Center Configuration Manager
Cloud deployment
Package update deployment
Publishing packages
User State Virtualization
Repairing an App-V package
Usage reports
11. Now that we have assigned a group of users or computer to the
package, we can Publish the package so it becomes available.
Click on Publish in the lower right corner.
The package is now published to the appropriate AD group(s) and will be
available the next time the App-V client for the users or computers in the
group is synchronized with the App-V Publishing Server.
Because the synchronization runs at an interval, it may take a few
minutes (default value is 10 minutes) for application to become available.
There are two ways to speed this up.
1. Manual restart the AppvPublishing Application Pool in IIS on the
Publishing server.
2. Change the refresh interval in the registry.
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AppV\Server\PublishingS
PUBLISHING_MGT_SERVER_REFRESH_INTERVAL = 600
(default setting in seconds / 10 minutes)
PUBLISHING_MGT_SERVER_REFRESH_INTERVAL = 60
(common value used for test environment / 1 minutes)
The amount of data that will be streamed to the client is dependent on the
size of the package containing the application or applications and how
the package was sequenced.
It may take a couple of minutes before the package
becomes visible since the Publishing Server needs
to synchronize with the App-V database.
Near the top of the Packages list, you see a Search
box. As its name implies, it allows you to search
for packages based on a word or phrase.
3. Click on the package that you want to edit.
4. Click on Edit Default Configuration in the lower right corner.
5. From the Applications tab it is possible to enable or disable virtual
applications. Click on the Enable or Disable button on the lower right
corner to change the status.
6. In the Shortcuts tab it is possible to Add, Edit and Remove shortcuts.
It is not possible to disable shortcuts and every shortcut must be
bound to an application from the Applications tab.
Using the dropdown list, you can set the location for a shortcut. It
offers a set of standard locations but you are free to choose Custom to
define your own location.
7. All the File Types associated with the package are displayed in the
File Types Association tab. File Types cannot be added, edit or
removed from the Management Console.
8. The Advanced Tab offers the possibility to export the current settings
to a Dynamic Configuration file. This file can be modified and, using
the Import and Overwrite this Configuration button, imported so it
overwrites the current settings.
The export feature can also be used as a safety net to restore the
settings before making modifications.
Near the top of the Packages list, you see a Search
box. As its name implies, it allows you to search
for packages based on a word or phrase.
3. Click on the package that you want to edit.
4. Click on the down arrow next to the Active Directory group you want
so assign a custom configuration and click on Custom
Before the App-V PowerShell commands can be
used, the AppVClient module must be imported.
Adding packages to the system using PowerShell
1. Open PowerShell as an Administrator
2. Run the following command to add a package to the system, publish
the contents and mount the package so it is fully loaded in the App-V
cache. Change the name of ACDsee to your package name.
Add a package that is stored locally:
Add a package using HTTP:
Adding all packages from a folder to the system using PowerShell
To easily import all packages in sub folders from a directory use the
following script:
1. Open PowerShell as an Administrator
2. Run the following command to add all package in a subfolder to the
system, publish the contents globally and mount the package so it is
fully loaded in the App-V cache.
Get-ChildItem -Filter *.appv -Recurse | ForEach-Object {Add-AppvClientPackage -Path
$_.FullName | Mount-AppvClientPackage | Publish-AppvClientPackage -Global}
The import may take a while depending on the number of packages and
integration points that exists in the package.
Applying a Dynamic Deployment Deployment configuration file
The following command configures an already existing App-V Client
Package using a Dynamic Deployment configuration file.
1. Open PowerShell as an Administrator.
2. Run the following command to apply the settings in a Dynamic
Deployment configuration file to the package.
Remove a package
Although Remove-AppVClientPackage is sufficient to remove an
application from the system, sometimes the package is in use and needs
more commands to successfully be removed.
1. Open PowerShell as an Administrator
2. Run the following command to force closure of the application and
afterwards unpublish and remove the package.
Revert the application settings for WinRAR to its original settings.
Synchronise with the publishing server
Add App-V Connection Group
The package is now added to the SCCM Management console and from
here it can be deployed to the clients.
Deploying App-V applications using System Center Configuration Manager
After an App-V package is added to the Applications part of SCCM, it
can be distributed to the distribution point and from there deployed to the
client.
When deploying App-V applications using System Center Configuration
Manager (SCCM), you still need to ensure the App-V Client is deployed
to your end user. There also needs to be a collection available where the
clients reside that needs to receive the virtual application.
1. Open the SCCM Management console
2. Click on Software Library
3. Expand Application Management
4. Click on Applications
5. Click on the application that needs to be deployed.
6. From the ribbon at the top, click deploy.
7. Click the Browse button next to Collection and select the correct User
or Computer collection.
8. Click Ok
9. Click Next
10. In the content screen of the wizard, click Add and select Distribution
Point.
11. Check the content Distribution Point and click on Ok
12. Click on Next
13. The next screen allows the package to be deployed mandatory
(Required) or that the end user can select the application from the
Software center (Available).
14. Click Next.
15. By default, the application will be available as soon as possible but it
is also possible to delay the deployment. To delay the deployment,
select Schedule the application to be available at and select a data
and time. Click Next.
16. The next screen allows setting the user notifications that the user
receives.
17. If you are using System Center Operations Manager, it is possible to
set the system to Maintenance. Click Next.
18. Click Next in the summary screen
19. Wait for the progress to finish and click Close.
Now that the wizard is complete, the package will be distributed to the
distribution point of SCCM and from the copied to the SCCM client
cache. When it is fully downloaded it is placed in the App-V client cache.
When using System Center Configuration Manager
to deploy virtual applications, the packages are
placed twice on the system. Once in the SCCM
cache and once in the App-V client cache.
Publishing packages
Global and User Publishing
App-V packages can be published to a user and to a system. When it is
published to a user, it is only available to that user or a subset of the
users. Shortcuts are stored in the current user account profile and other
extension points are stored in the registry in the
HKEY_CURRENT_USER hive.
If it is published global, it is published to the system and it then becomes
available to everyone that logs on to that system so all users on that
machine can use it. Shortcuts are stored in the All Users profile location
and other extension points are stored in the registry in the
HKEY_LOCAL_MACHINE hive.
By using the PowerShell command: Get-AppVclientPackage you can see
if the package is published Globally or if the package is published to a
user.
RunVirtual
Since Service Pack 2, App-V 5 offers the possibility to use a registry key
to run a locally installed application in a virtual environment.
First this was only available for packages that were published Global but
since SP3 this feature also works for packages that are published to the
use.
RunVirtual cannot be set using the
Management console. Use other tools to
configure the RunVirtual registry key.
1. Open PowerShell
2. Run the command: Get-AppVClientPackage All
3. All the packages on the system become visible.
4. Find the PackageId and the VersionId of the add-on or plug-in
5. Navigate to
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AppV\Client\RunVirtu
6. Create a new subkey that contains the executable name of the local
application. For example, Excel.exe
7. In the Default key, add the <PackageId>_<VersionId>
Now when Excel is started, the virtual application will be visible from
the local application.
If you want to use the RunVirtual key for packages that are published to
users, change to registry location to
HKEY_CURRENT_USER\SOFTWARE\Microsoft\AppV\Client\RunVirtual
PowerShell
The PowerShell cmdlet Start-AppVVirtualProcess can be used to start a
native application process within the virtual environment.
The first step is to store the package information in an environment
variable and use that information to start the virtual environment.
$Package = Get-AppvClientPackage *<Part of package name>*
Start-AppvVirtualProcess -AppvClientObject $Package cmd.exe
A network location to store data from application settings, default
the home folder will be used.
Installing and configuring the client and generating profiles is beyond
scope of this book but on the Microsoft website there is plenty of
information available that will guide you step-by-step through this
process.
Now that UPD is enabled, the RDS systems in the Resource pool have full
control permission on the share where the UPD files reside.
There are also 3rd party solution to manage user
settings and these offer even more functionality
than UE-V and RDS User Profile Disks. These
tools are out of scope of this book.
PreserveUserIntegrationsOnLogin
When using tools like UE-V and UPD to save the user settings, this can
also include the App-V information like the integration points. This
information is restored at logon prior to publishing.
Since this can lead to conflicts, the App-V client has a built-in cleanup
phase which checks if the App-V information on the client
correspondents with packages on the system. If not, it removes the
information and reapplies them during the publishing phase.
During the cleanup it could be that icons are
removed and restored after a few seconds when the
publishing completes.
When using UE-V or UPD, this cleanup phase could be disabled, because
both solutions apply the user integrations to the system prior to
publishing. To disabled the cleanup phase, App-V has an option since
SP2 Hotfix 4 that is called PreserveUserIntegrationsOnLogin.
Enable PreserveUserIntegrationsOnLogin on the client
1. Open Regedit as administrator
2. Navigate to:
HKEY_LOCAL_MACHINE\Software\Microsoft\AppV\Client\Integration\
3. Create a new DWORD called PreserveUserIntegrationsOnLogin
4. Enter the value 1
5. Restart the App-V Client or the system.
Usage reports
App-V 5.0 contains a reporting feature that provides information about
virtual application package usage, the client operating system and
architecture and the client information. It gathers this information from a
centralized database which is specified during the installation of the App-
V server.
Usage information for applications are even if the user is offline or not
connected to the App-V infrastructure
Reporting is not enabled by default.
Client Setup
The App-V client sends the reporting data at a specific interval or when
the PowerShell command Send-AppvClientReport is executed. After the
reporting server receives the data it sends the data to the reporting
database. When the database receives and processes the client data, the
local reporting cache of the App-V client is emptied unless you configure
it to preserve the cache.
To enable the client to send the usage information to the reporting server,
run the PowerShell command:
Set-AppVClientConfiguration ReportingServerURL
http://servername/reportingsite -ReportingStartTime 30 -ReportingInterval 1 -
ReportingRandomDelay 60
It is also possible to set the values using the App-V Group Policy
extension:
Reporting
To retrieve information from the reporting database and create reports
using App-V 5, Microsoft SQL Server Reporting Services is necessary.
Afterwards, there are 9 sample reports from Microsoft that can be
uploaded to the reporting server to provide reports about App-V
applications, users, and computers, these are:
Total running time by virtual application
List of virtual applications by user
List of execution details for virtual applications by user
List of distinct virtual applications by user
Count of distinct virtual applications by user
Count of all instances of virtual applications by user
Count of all instances of virtual applications by computer
Count of all Instances of virtual application packages
Computers with a specific virtual application
The reports can be downloaded from http://www.microsoft.com/en-
us/download/details.aspx?id=42630
Summary
In this chapter, we looked at the deployment of App-V packages and
Connection Groups.
First, we learned how to choose the right delivery method. We learned
how to deploy using PowerShell, the Full Infrastructure and SCCM.
After the deployment was done, we showed how to modify and upgrade
a package. This is an important step to keep your applications up to date
and correctly configured.
In the next chapter, we will look into backing up and harden the App-V
environment. We also show you how to recover an App-V environment.
Chapter 6 - Backup, Security and
Recovery
You cant anticipate events in the future but you can be prepared when
things might not go as planned. Being prepared means that you build
safety nets so you can revert to a stage where everything works fine.
Does your organization have a process and the tools to ensure that you
can revert to such a stage? Thats great, then you can use this process and
tools for your App-V infrastructure. If not, make sure that you create one
because when failure occurs, you will need it.
In this chapter:
Backing up the server
Secure the App-V environment
Recover an App-V environment
Operating System
Every App-V component runs on a Windows operating system. General
security hardening should be performed since this component could be a
weakness if not proper secured, patched and hardened. Make sure to keep
current with all software updates since this provides solutions to known
security issues. A system that is up-to-date is difficult for attackers to
exploit vulnerabilities.
SSL/TLS/HTTPS
The Management console and the Publishing server make use of HTTP
and are unsecure by default. So it is best practice to get a certificate and
assign it to the website to achieve higher levels of security. Certificates
are used for securing many types of network communication in an App-V
infrastructure. The certificate name must match the DNS record of the
website.
When using HTTP for streaming packages from the content store this
also can be secured using HTTPS but the consequence is that every
package will be send encrypted over the wire. This has a negative impact
on performance since the CPUs need to decrypt all the content bit by bit.
Firewall
Utilizing a firewall on the server can help reduce the attack surface area.
Windows Firewall with Advanced Security includes a host-based firewall
component that is a protective boundary for the local computer, which
monitors and restricts information that travels between your computer
and its attached networks or the Internet. It provides an important line of
defense against someone who might try to access your computer without
your permission.
The App-V installer does not modify firewall
settings. You must also add the associated firewall
rules to allow incoming requests to access the
specified ports.
All communication between the App-V Publishing Server and App-V
Client is initiated by the App-V Client. The built-in Windows Firewall
requires no additional configuration in order for the client to
communicate in this fashion.
File Security
Data leakage has always been a concern for the Enterprise customers,
packages will be placed in a file repository that must be accessible for
end-user so they can retrieve their applications. These resources need to
be as secure as possible to better protect the data for any possible
leakage.
Although users need access to the packages they are entitled to use, other
packages on the location where the packages reside should be protected
by NTFS permissions by applying the most restrictive permissions.
Since the App-V Management Console associates the right to use an
individual application with an Active Directory group, the same group
can be used to only assign read rights on the package location.
AppLocker
The goal of AppLocker is to improve the security of each computer by
blocking unwanted processes that are not permitted to run. Processes that
do not match the rule set configured are blocked.
Be careful with prohibited processes like AppVSHNotify.exe and
AppVStreamingUX.exe since these are required by App-V and
responsible to send notifications to the Windows Shell. This process runs
under the user context and only runs if there are applications published to
the user.
Management Console
Be careful allowing users to the App-V Management console since it has
no delegation of control, every user that has access to the Management
Console has full control over the whole App-V environment.
Antivirus exclusions
Antivirus provides an important line of defense against someone who
might try to modify your computer without your permission. Especially
App-V is a risk since Windows Defender and other antivirus applications
should be turned off prior to sequencing. This means that is best practice
to scan the installation sources before sequencing and scan the sequencer
after installation. If an applications setup file must be downloaded from
the internet, make sure to download it from a computer with active
antivirus.
There are no recommended antivirus or antimalware exclusions for App-
V 5 by Microsoft.
Although there are no recommendations, there are a few locations that
can be excluded to gain a performance gain:
Component Exclusion
Management %SystemRoot%\system32\inetsrv
Server
%SystemDrive%\inetpub\temp\IIS Temporary Compressed Files
Reporting
Server
Publishing %SystemRoot%\system32\inetsrv
Server
%SystemDrive%\inetpub\temp\IIS Temporary Compressed Files
Content
Share
Windows %SystemDrive%\Pagefile.sys
Server
%WinDir%\System32\spool\
% WinDir %\SoftwareDistribution\Datastore
%WINDIR%\SoftwareDistribution\Datastore\Logs
%WINDIR%\Security\Database
%SYSTEMROOT%\System32\GroupPolicy
PackageStoreAccessControl
Since App-V 5 SP2, the PackageStoreAccessControl is discontinued.
This setting used to lockdown the PackageInstallationRoot (cache
location) to who has not been authorized to access a particular package.
Although it does not protect the user from downloading a package and
use it on another system, the RequirePublishAsAdmin feature could still
prevent user from adding packages unauthorized.
RequirePublishAsAdmin
This setting enables only administrators to publish and unpublish
packages. By default, non-administrators are allowed to publish
applications on the system.
This is great for example, laptop users since this makes it possible for
end users to add their own applications. But from an administrative or
security perspective this might not be desirable. App-V allows an
administrator to disable end users to publish applications on the system.
To enable this feature, and thus disabling publishing by end users, run the
following PowerShell command:
Set-AppvClientConfiguration -RequirePublishAsAdmin $true
In App-V 5, in contrast to version 4, users do not
require authorization for cached applications. This
means that applications that have been streamed
from the server will not require authorization from
the App-V infrastructure before launching.
Disaster Recovery
One thing is for sure, failures occur. High availability can help toward
mitigating the negative impacts of small and simple failures but the most
common data loss scenario is simply a user inadvertently deleting or
overwriting a file and high availability does not cover that.
One of the most-ignored activities in disaster recovery is the need to
ensure that the plan can actually be used. A good disaster recovery plan
should include periodic verification of backup data and failover/failback
tests of the replica system.
The data in an App-V environment resides in two different types of
storages. Data is stored for the App-V infrastructure in the SQL database,
while virtualized applications and user data are housed on separate
storage. Backup both to avoid data loss in the event of a disaster.
Restore the App-V database(s)
1. Log in to a SQL Server on the Delivery Controller.
2. Launch Microsoft SQL Server Management Studio and then connect
to the database engine.
3. Expand the Databases node and navigate to the App-V database
4. Right-click on the database and select Tasks, then click on Restore,
and finally Database.
5. Select the backup set from which you want to restore. Click on Ok
6. After a successful restore operation, you will need to restart each
App-V server.
Summary
In this chapter, you learned what is important for the continuity of your
App-V environment.
We looked at how to backup your App-V environment and the things we
can do to secure the infrastructure. We did this by restricting our users
from access the file repository where the packages reside and using
security features like SSL/TLS and PackageStoreAccessControl.
In the next chapter, we will look into performance and how to improve
this for the App-V environment, maintenance tasks that need to be
carried out weekly, monthly and yearly and how to proper monitor the
environment.
Chapter 7 Performance, Maintenance
and Monitoring
A technical solution is only viable and considered a success if users have
an experience they wish.
So far we have gone through different scenarios of installation,
configuration, deployment as well as backup and security. In this chapter
we will focus on how we can tune our solution to gain better
performance.
Each release of App-V brings the promises of improved stability, better
performance, faster publishing, and so on. Although this might be true in
some scenarios, optimization might be necessary to achieve this.
In this chapter:
Performance guidance
Maintenance
Monitoring
Performance guidance
In the latest releases of App-V, performance became more and more
important and minor improvements have been made in making the
performance better. Especially publishing times in a hosted desktop and
integration with User Profile Management (UPM) solutions had a great
focus.
Some amazing facts:
20,000 clients can target a single publishing server to obtain the
package refreshes;
A single management server can support up to 50 publishing
servers for package metadata refreshes;
A single reporting server can process 500 concurrent/active
connections;
A single reporting server can process a maximum 1500
concurrent connections;
You can support 500.000 clients with:
5 publishing servers
2 reporting servers (requirement: with 4 hours random delay)
1 management servers
1 database
Despite the improvements to performance made in version 5 there still
may be times when it doesnt work as quickly as you might hope.
The most frequent complaint that App-V administrators receive from
users is about applications starting slowly. They certainly do not consider
the fact that, at least for the first time, when you launch a virtualized
application, an entire streaming process takes place.
Performance is closely tied to certain configuration choices made when
selecting (virtual) hardware variables such as the number of CPU cores,
memory speed and storage. But also software variables such as profile
type, mounting packages and tuning. These variables play crucial roles in
the delivery of an uncompromised user experience, system density and
scalability.
How to optimize your App-V environment depends on the type of
workspace that is being used. In a hosted desktop in the datacenter,
storage is more expensive and often a limited amount is available. A fat
client or laptop often has enough local storage and profiles arent
removed at logoff. Both types of workspaces require a different approach
for performance tuning.
Hosted Desktop
A hosted desktop offers a user desktop environment in the datacenter
where users share the underlying hardware. The desktop consists of a
combination of technologies like a hypervisor, broker and profile
virtualization.
In general, there are three forms of hosted desktops:
1. Virtual Desktop Infrastructure (VDI) - Persistent desktop
Changes to the desktop are saved when a user logs off. This is the
most user friendly form of a hosted desktop.
2. Virtual Desktop Infrastructure (VDI) - Non-Persistent desktop
Changes to the desktop are lost when the user logs off and the
desktop is returned to a pool of desktops and is available for other
users.
3. Server Based Computing (SBC)
When using Server Based Computing, there are multiple users
working on the same desktop and changes are lost when logging off.
Challenges with VDI Non-Persistent and SBC are that the modifications
users make to their desktop are lost when they log off. This is due to the
fact that the profile is removed at logoff or the user is redirected to a
different desktop at logon so their settings are not available.
Building a new profile at logon requires time and when the profile is
created the virtual applications arent available before the
synchronization has been run.
UE-V makes it possible to save the modification(s) the user makes to
their desktop and restore those settings when the user logs on. This
makes the logon process quicker and makes it possible to save and
restore the publishing state of the App-V packages for the user. See
chapter 5 for more details about UE-V.
When using VDI, there is a virtual machine in the datacenter for every
user that logs on. These virtual machines are stored on more expensive
storage than storage that is available for desktops and laptops. When
using App-V to deliver the virtual applications to those desktops, the data
of the packages is written to the storage multiple times and thus using
more expensive storage.
Since App-V 5 it is possible to use the Shared Content Store (SCS)
feature. When using SCS, only publishing data is placed on hard disk and
the virtual application is streamed into memory (RAM) over the network.
This save a tremendous amount of storage in the datacenter making it a
must have for every VDI implementation.
The Shared Content Store (SCS) uses the same location where the virtual
applications reside as when not using SCS. You only need to set the SCS
option to true using PowerShell, Group Policy or installation parameter.
When using the Shared Content Store it is advisable that the files of the
virtual application are placed on storage with low latency to the App-V
client because the bits are streamed from the network when the client
needs them.
The Shared Content Store is now enabled after the product is installed.
Enabling Shared Content Store using Group Policy
Make sure that the Microsoft Desktop Optimization Pack Group Policy
Administrative Templates are imported.
1. Open the Group Policy editor
2. Navigate to Computer Configuration, Administrative Tools, System,
App-V, Streaming
3. Open Shared Content Store (SCS) Mode
4. Click on Enabled
5. Click on OK
The Shared Content Store is now enabled.
A publishing refresh creates excessive CPU usage.
In a Server Based Computing environment, it is
recommended to limit the publishing refreshes.
Speed up the Publishing phase
When using small packages, it generally seems fast, starting rapidly and
responding at speed to whatever you ask it to do.
With large packages that contain integration points, it could take longer
before the package is added, published and mounted. The number of files
and Extension Points affect time-to-publish.
PreserveUserIntegrationsOnLogin and UE-V or other user profile tools
can speed up the publishing phase.
Also, an Application Pool is recycled every 29 hours. So the first request
that reaches IIS after the application pool is recycled will process very
slowly because the application pool is set to work on demand. Recycling
can be disabled by setting the value to 0 in the Advanced Settings of the
Application Pool.
Maintenance
Maintaining the status of the App-V environment is very important to
keep all the systems in prime condition. An App-V environment that is
not available has a high impact on the end-users productivity so keeping
it available is important.
Weekly activities
Rebuild database table indexes
See if any services need scaling up (more CPU/memory/disk) or
out (more instances) to meet requirements.
Monthly activities
Check for security updates
Review permissions in the App-V Management console. The set
of App-V administrators should be kept to a minimum.
Yearly activities
Restore backups to another test server in order to verify that they
can be restored.
Monitoring
To operate effectively, most organizations rely on IT as a core function.
And so, a process should be in place that can include examining
application logs or viewing performance graphs on servers to help
resolve an issue or prevent an issue that might occur in the environment.
This chapter focuses on which components of App-V to monitor.
There are many monitoring solutions available to automate this. For
example, System Center Operations Manager (SCOM). Operations
Manager provides performance, health and availability monitoring of the
infrastructure, applications and services in the IT environment.
SCOM can be extended with Management Packs, there is also a
Management Pack available for App-V.
This pack includes:
Discovery of the Application Virtualization 5.0 Services:
Management, Publishing, Reporting;
Alerts indicating availability/configuration/security issues that
require administrative intervention;
Collection Rules defined for significant events in ETW logs of
each App-V 5.0 Service;
Verification that dependent services are running;
Notification of security issues involving admin access attempts,
admin added/deleted on App-V 5.0 Management Server.
This can be download from: https://www.microsoft.com/en-
us/download/details.aspx?id=38418
Services
The App-V infrastructure is highly dependent on running Windows
Services. Sometimes these services fail to start or accidentally stop, and
this leads to outages and user productivity losses.
The following services should be monitored that they are running:
General
Its difficult to define which values are good for the counters in advance;
this usually depends on the size of the infrastructure, the number of
connected users, and so on. A better approach is to record the values
during normal conditions (baselining) and compare the actual values with
the baseline.
Make sure the next performance counters.
Disk activity
Since the App-V clients will read the package contends from the file
repository, it is crucial that the disks where the packages reside has
enough capacity and performance as needed. Also check the
fragmentation level of the non-ssd disks regularly because if a disk is
highly fragmented, it takes the machine longer time to get the package
content and deliver it to the App-V clients.
Disks should be monitored with the following counters:
%Disk Time
Avg. Queue Length
Processor utilization
%Processor Time
Memory usage
Available bytes
Summary
In this chapter, you learned what you can do to improve the performance
of App-V. This is extremely important since it involves the end-user
experience with the product.
We looked at what the Shared Content store is and how to enable it for
the App-V Client. We also saw how to improve publishing performance
and what tasks need to be performed for our App-V environment to keep
it up and running.
Microsoft has done a good job as it has, out of the box, configured to
deliver the best performance, and it makes it a lot easier with the latest
release of Windows Server, but there is always room for improvement.
In the next chapter, we will look into troubleshooting and tools that will
make our life easier.
Chapter 8 - Troubleshooting
Implementing App-V or moving to a new version of App-V can result in
all kinds of subtle issues with your environment. A well designed and
implemented App-V infrastructure can run without disturbances for a
long time, but it is inevitable that you will be faced with unavailability of
the environment from time to time. Converted packages may fail to run
or different error messages pop-up. Dont rush to blame Microsoft
because the real cause of these problems often lies in the configuration of
the environment.
Dont start changing program settings, Windows settings, registry
settings, deleting files, and taking other action without an understanding
of what youre doing. Just as important, dont make lots of changes at
once. Instead, make a single change, see if it fixes the problem, and then
try the next if needed.
The most important step to solve problems is to find out the cause. App-
V offers different options to find the cause of a problem and see the
details.
In this chapter:
Troubleshooting Deployment
Troubleshooting Packages
Tools
Troubleshooting deployment
App-V Event Log
The most common way to start troubleshooting an App-V issue is to use
the Windows Event Log. App-V writes operational events to the event
log that is viewable by using Event Viewer.
In earlier versions of Windows, most information of interest to an
administrator was found in the System and Application logs. Starting
with Windows Vista and later versions of Windows, the Event Viewer
includes many predefined filtered views.
The original, unfiltered System and Application logs can be found under
Windows Logs. The filtered list of App-V with Admin, Operational and
Virtual Applications events can be found under Application and Services
Logs, Microsoft, AppV, Client.
These three event logs display the most common errors, warnings and
informational events.
Opening the App-V Client Event Logs
1. Click Start, click Administrative Tools, and then click Event Viewer.
2. In the navigation pane, expand Applications and Service Logs,
expand Microsoft, expand AppV, expand Client.
3. Click on Admin, Operational or Virtual Applications to display the
events.
The Event Logs for the sequencer are under
Microsoft, AppV, Sequencer and contains Admin
and Operational information. The sequencer also
contains Analytic and Debug logs.
If the package is in use when a new version is available and ready to be
published, the App-V client will add the package to the system and create
a key in the registry with the PackageId and the VersionId.
For user published applications the key will be created under
HKEY_CURRENT_USER\Software\Microsoft\AppV\Client\PendingTasks
named PublishPackage.
For global published applications the key will be created under
HKEY_LOCAL_MACHINE\Software\Microsoft\AppV\Client\PendingTasks
A user published application is replaced at the next logon. A global
published application is replaced at the next reboot. After the new verion
of the package is successfully published, the registry key will be
removed.
Please note that although there are two parameters, UserPending and
GlobalPending, in the PowerShell command Get-AppVClientPackage to
display the current update status, these both do not display the correct
state. The registry will display the correct state.
The error also is written to the Event Log so more details about the error
can be found there.
For example:
Failed to load provided xml.
DOM Error: 0xC00CEE3B
Reason: The name in the end tag of the element must match the
element type in the start tag.
Line: 395
Column: 25
Offset: 0
This displays where the error is located (line 395) so opening the file in a
text editor with line numbers, like Notepad++, makes it easy to locate the
location where the error is. In this example the end tag of the element
was removed. Often it is a mistake that an element is removed or text is
entered in lower case. Using the Event Viewer, it is easy to trace where
the error is located.
To avoid errors when modifying Dynamic Configuration files, you can
use the freeware application: App-V 5 Configuration Editor (ACE) to
modify the files.
3. Enter the correct values in the URL:
http://APPVPUB:9001/?
clientversion=5.0.10066.0&clientos=WindowsClient_6.2_x64
It is also possible to view the packages and Connection Groups that
others are entitled to use by opening the browser in their security context
and open the Publishing Servers webpage.
Running it in the system context displays the Global published packages
and Connection Groups.
Troubleshooting Packages
By default, locally installed applications cannot view the virtual file
system of an App-V package. If it is necessary to view the virtual file
system from an application that is locally installed, there are a few
options.
Change the name of PSPad to a part of the application that you want
to use.
5. Now that the information is in the variable $package it is possible to
use that information to start a local process.
6. In the same PowerShell window, run
Start-AppvVirtualProcess -AppvClientObject $package cmd
Now that the Command Prompt is opened it is possible to view the
contents of the virtual application by navigation to the installation folder.
Tools
Tools make the life of an administrator easier and improve the usability
of the App-V product. Fortunately, there are a lot of (free) tools available
to use. Using the tools directly on a local computer is useful to view and
manage the current configuration that is active on the computer and the
packages that are added.
AppV_Manage (free)
This is a tool to test and debug your new packages. Especially useful for
people packaging in App-V 5 for performing the initial tests on their
sequenced packages. It is used on an App-V client test machine, and
requires no back-end servers (although a file share where the packages
are stored is typically used). You sequence, copy the package up to the
share, and bounce over to the client to test.
Available from http://www.tmurgent.com
Available on http://www.adminscope.com/downloads/app-v-commander/
GAP-IT (free)
GAP-IT has the ability to provide an administrator insight in the App-V 5
publishing times. These times are reported per individual package which
is useful information for further package optimizations.
Available from http://www.logitblog.com
The tools listed in this chapter are by no means an exhaustive list of the
tools that are available for App-V (troubleshooting). It is important
always to be on the lookout for new tools and to experiment with the
various tools that are available.
Summary
This chapter has been all about the many ways you can troubleshoot the
App-V environment. We looked at the Event Log which is the first step
in troubleshooting App-V.
Then we looked at some options the App-V Client offers to troubleshoot
when errors occur and afterwards we looked at some of the tools
available from 3th parties which offer help when troubleshooting issues.
The next chapter will focus on some of the more advanced features of
App-V.
Chapter 9 For the experienced
If youre an advanced user and want to be able to get more out of App-V,
the next chapters are for you.
In this chapter:
PowerShell scripting
Package content
Copy-on-Write excluded extensions
Integration Points
Tokens
Pass-through keys
Dynamic Virtualization
PowerShell Scripting
The App-V components can be completely managed using PowerShell. If
the user account is a standard account, there are some limitations to what
the user can do. Basically, the standard account cannot make any changes
to the system that would affect other users.
Running PowerShell scripts can have very serious
consequences. Who dont have sufficient
knowledge to understand the risks involved in
using PowerShell should not run these commands.
Import or add all App-V package in a directory to the Management console:
Give an Active Directory group access to an App-V package:
Publish an App-V package in the Management console
Remove a App-V package from the Management console:
Remove-AppvServerPackage -name
Assign an Active Directory group to all App-V packages:
Add a package to a Connection Group
Add-AppvServerConnectionGroupPackage -ConnectionGroupID
<ConnectionGroupId> -Optional -PackageName
WinMerge_2.6.6_EN_V1 UseAnyPackageVersion
Create a new Connection Group
Add-AppvServerConnectionGroupPackage -ConnectionGroupID
105b1ead-1981-4f34-9d0a-375297a3ab42 -PackageName
CoffeeCup_HTML_Editor_15.1_781
Edit details about the connection group package (optional, etc)
Remove a package from a Connection Group package list
First, get the Connecion Group ID by running:
Get-AppvServerConnectionGroup
Then, get the name of the Package that you want to add by running: Get-
AppvServerPackage
Afterwards, run the following command after changing the values
Remove-AppvServerConnectionGroupPackage -
ConnectionGroupID 105b1ead-1981-4f34-9d0a-375297a3ab42 -
PackageName CoffeeCup_HTML_Editor_15.1_781 -
PackageVersionID 15c8adbd-c4f7-4b35-89c9-12135079136f
ROOT
The ROOT folder contains all the files captured during sequencing.
In the ROOT folder there is default a subfolder called VFS unless the
PVAD is used. The PVAD creates a folder with the application name. For
more information about PVAD/VFS see the PVAD/VFS chapter.
Scripts
The Scripts folder contains the scripts added during sequencing. See the
chapter about adding scripts during sequencing for more information
how to add and how to use scripts.
[Content_Types].xml
Contains a list of the essential files within the .APPV file using the Open
XML format Content Type. For example:
<Default Extension=ico ContentType=appv/vfs-file />
AppxBlockMap.xml
This file contains a layout of the App-V file to proof the authentication of
the App-V package.
AppxManifest.xml
Contains information that is needed when a package is added, published
and launched. For example, FTA information and shortcuts.
FilesystemMetadata.xml
All the files and directories that are captured during sequencing and
information about them, like the shortname. For example:
<Entry Long=WinMergeU.exe Short=WINMER~1.EXE />
PackageHistory.xml
Contains information about how the package is created, for example
information about the sequencing machine (processor, user, locale, save
mode, etc.).
Registry.dat
The registry keys and their values captured during the sequencing
process.
StreamMap.xml
Contains the list of files for Feature Block 0 and 1.
Feature Block 0 is the Publishing Feature Block, it contains everything
required for to publish the packages such as a portion of files (EXE and
DLL), shortcuts and icons.
Feature Block 1 is created during the Streaming phase in the sequencer
and contains all the application parts that need to be available first when
a user starts the virtual application.
Copy-on-Write
The Package Store contains a pristine copy of the package files that have
been streamed from the publishing server.
The changes and end-user makes to an application are not stored in the
package store in order to preserve the ability to repair the application,
which removes these changes.
Modifications made by the user to the package store are written to two
Copy-on-Write (COW) locations. Depending on how the application is
programmed, it will use the roaming or non-roaming location to store the
modifications.
%AppData%\Microsoft\AppV\Client\VFS
Location for package modifications that are written in roaming
locations.
%LocalAppData%\Microsoft\AppV\Client\VFS
Location for package modifications that are written in non-
roaming locations.
For example, if an application writes to AppData, it is placed in
this folder since this is a location that is not being roamed when
using a roaming profile.
In the non-roaming location there could be folders which contain
an S. The S indicates a restricted location which is being created
when a different, elevated, user makes changes.
Excluded extensions
The App-V client contains a list of excluded file types, which are not
allowed to be written into the virtual environment. In 5.1 the App-V
client does not allow the following file types:
.exe
.dll
.com
.ocx
Integration Points
Each virtual application is isolated from the local system and runs in a
bubble. However, sometimes it is necessary to break out of the bubble
and integrate parts of the virtual environment on the local system. For
example, a shortcut to an application in the virtual environment.
App-V contains manifest and Dynamic Configuration files that contain
extension points.
The current App-V extension points are:
Shortcuts
Shortcuts are the main mechanisms by which a user can launch
an application. The Shortcuts subsystem captures shortcuts that
were created during installation.
File Type Associations
This subsystem allows file extensions to be associated with
applications. For example, if the user double clicks a .DOCX file
the virtual package of Word 2013 will be opened and the
document is displayed.
Shell Extensions
Shell extensions enable end users to right-click on a file and see
options available which use Windows Explorer to send paths and
file names as arguments to App-V executables before they launch.
COM
In charge of integrating COM objects from the virtual application
to the native operating system.
Software Clients
This will include virtual applications to be set as default programs
for certain activities.
Application capabilities
Displays the capabilities of the virtual application to the operating
system. Using this feature, it is possible to set virtual applications
as defaults for file types and protocols.
Drag-and-drop
Displays options when a user drag-and-drops on the virtual
application.
Property sheet
Add or replaces pages in the properties sheet of the dialog box.
For example, if you package an application that extends the
features of a special mouse. That application can replace the tab
of the Windows Mouse Control panel so it becomes visible.
Infotip
Allows retrieving flags and infotip information for an item and
displaying it inside a popup tooltip upon mouse hover.
Data object
Defines what to do when a file from the virtual environment is
copied to the clipboard.
Drop target
Defines what to do when a file is dropped onto the virtual
application.
Column
Enables creating custom columns in Windows Explorer Details
view and by this, extend sorting and grouping.
Pass-through Keys
Pass-through keys enable an administrator to configure certain keys so
they can only be read from the native registry, bypassing the Package and
COW locations.
This is designed to ensure that a virtual application does not write data in
the virtual registry that is required by a native application for successful
operation or integration.
It is not recommended to modify the pass-through
keys! If it is necessary, only add keys and do not
remove keys.
The pass-through keys are saved in a registry key located in
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AppV\Subsystem\VirtualReg
The following locations are default included in this key:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentV
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\even
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\WMI
HKEY_LOCAL_MACHINE_CURRENT_USER\SOFTWARE\Microsof
Settings
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows
NT\CurrentVersion\Perflib
HKEY_LOCAL_MACHINE\SOFTWARE\Policies
HKEY_CURRENT_USER\SOFTWARE\Policies
Dynamic Virtualization
Dynamic Virtualization is a great feature that is available since App-V 5
SP2 that makes it possible to automatically make virtual components,
like shell extensions and Active-X controls, available when a local
process like explore or iexplore is started. Dynamic Virtualization is
sometimes called JITV or Just-in-Time Virtualization.
The processes that are specified for Dynamic Virtualization are listed in
ProcessesUsingVirtualComponents. Default explore.exe and iexplore.exe
are added.
Without Dynamic Virtualization, the end-user always has to start the
virtual environment by using, for example, shortcuts. This less user
friendly, especially when using Internet Explorer plug-ins or applications
that integrate in the context menu.
With Dynamic Virtualization, applications can integrate in the context
menu so there is no difference between native and virtual applications.
In the above screenshots, UltraCompare and published it to the system.
In the left screenshot Dynamic Virtualization is turned on (default) so
Load in UltraCompare is integrated in the context menu. In the right
screenshot, Dynamic Virtualization is turned off and the Load in
UltraCompare option is not available anymore.
Although it is not available from the context menu, UltraCompare is still
published and available from the start menu, but the end-user must open
a file by starting the application and open it via File, Open. This is less
user friendly and takes more steps to complete.
Removing processes from Disable Dynamic Virtualization
The easiest way to remove a process so it wont be used by Dynamic
Virtualization is to edit the registry.
2. Open regedit and navigate to
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\AppV\Client\Virtualizatio
3. Remove the process from the key ProcessesUsingVirtualComponents
Summary
In this chapter, we did a deep dive into some of the more advanced
features of App-V. You learned where the .AppV file exists of and how
integration points work.
We looked at Dynamic Virtualization and how this can improve the user
experience.
Thats it, we have come to the end of a long App-V journey. In this book
weve described what Application Virtualization is and the components
that App-V exists of. Then we installed and configured the product and
virtualized applications. Afterwards we made these available using the
Full Infrastructure, PowerShell or System Center Configuration Manager.
In the last chapters we improved our environment by implementing
backups, security and performance. In the Troubleshooting chapter we
looked at the features available when things go wrong and in the chapter
was all about advanced features of App-V.
The next chapters will focus on where you can even be learning more
about App-V.
Learn more
The following websites are a great additional resource to read more about
App-V. They have been collected here for ease of reference.
Distribution Point A file share where SCCM places the content for
distribution to clients.
Fault Streaming Option to only transfers new bits into the cache
when the package needs them.
Package Folder with several files that contain all the files
for the virtual applications.
Package Accelerator File which contains all the settings that were
changed from the default.
User State Software product that can allows user data and
Virtualization settings to be transferred to a centralized location
in the data center, eliminating the limitations of
local storage and allow users to access their data
and settings from any desktop.
Virtual File System Location where all the files and folders are that are
(VFS) captured during sequencing.
Pass-through key Keys that can only be read from the native
registry, bypassing the Package and COW
locations.
Token Value
AccountPictures C:\Users\<username>\AppData\Roam
AppData C:\Users\<username>\AppData\Roam
Cache C:\Users\<username>\AppData\Local
Files
CD Burning C:\Users\<username>\AppData\Local
CommonMusic C:\Users\Public\Music
CommonPictures C:\Users\Public\Pictures
CommonRingtones C:\ProgramData\Microsoft\Windows\
CommonVideo C:\Users\Public\Videos
Contacts C:\Users\<username>\Contacts
Cookies C:\Users\<username>\AppData\Roam
CredentialManager C:\Users\<username>\AppData\Roam
CryptoKeys C:\Users\<username>\AppData\Roam
Desktop C:\Users\<username>\Desktop
DocumentsLibrary C:\Users\
<username>\AppData\Roaming\Micr
ms
Downloads C:\Users\<username>\Downloads
DpapiKeys C:\Users\<username>\AppData\Roam
Favorites C:\Users\<username>\Favorites
Fonts C:\windows\Fonts
GameTasks C:\Users\<username>\AppData\Local
History C:\Users\<username>\AppData\Local
ImplicitAppShortcuts C:\Users\<username>\AppData\Roam
Launch\User Pinned\ImplicitAppShor
Libraries C:\Users\<username>\AppData\Roam
Links C:\Users\<username>\Links
LocalAppDataLow C:\Users\<username>\AppData\Local
MusicLibrary C:\Users\
<username>\AppData\Roaming\Micr
My Music C:\Users\<username>\Music
My Pictures C:\Users\<username>\Pictures
My Video C:\Users\<username>\Videos
NetHood C:\Users\<username>\AppData\Roam
Personal C:\Users\<username>\Documents
PicturesLibrary C:\Users\
<username>\AppData\Roaming\Micr
Podcasts C:\Users\<username>\Podcasts
PrintHood C:\Users\<username>\AppData\Roam
Profile C:\Users\<username>
Programs C:\Users\<username>\AppData\Roam
Menu\Programs
Public C:\Users\Public
PublicAccountPictures C:\Users\Public\AccountPictures
PublicGameTasks C:\ProgramData\Microsoft\Windows\
PublicLibraries C:\Users\Public\Libraries
Recent C:\Users\<username>\AppData\Roam
RecordedTVLibrary C:\Users\Public\Libraries\RecordedTV
ResourceDir C:\windows\resources
Ringtones C:\Users\<username>\AppData\Local
SendTo C:\Users\<username>\AppData\Roam
Startup C:\Users\<username>\AppData\Roam
Menu\Programs\Startup
System C:\windows\system32
SystemCertificates C:\Users\<username>\AppData\Roam
SystemX86 C:\windows\SysWOW64
Templates C:\Users\<username>\AppData\Roam
UserProfiles C:\Users
VideosLibrary C:\Users\
<username>\AppData\Roaming\Micr
Windows C:\windows
AppVComputerName <USERNAME>-LT02
AppVCurrentUserSID S-1-5-21-124525095-708259637-154
AppVEnvironmentVariableCommonProgramFiles %commonprogramfiles%
AppVEnvironmentVariableProgramFiles %ProgramFiles%
AppVPackageDrive C:
AppVPackageRoot C:\AppInstallFolder
AppVSystem32Catroot C:\windows\system32\catroot
AppVSystem32Catroot2 C:\windows\system32\catroot2
AppVSystem32DriversEtc C:\windows\system32\drivers\etc
AppVSystem32Driverstore C:\windows\system32\driverstore
AppVSystem32Logfiles C:\windows\system32\logfiles
AppVSystem32Spool C:\windows\system32\spool
Now that youve read the book
Was it useful?
Did it teach you what you wanted to learn?
Was there room for improvement?
Let us know at http://www.packagingsupport.nl