Ransomware: A Serious Threat in Healthcare Cybersecurity 

In recent years, the healthcare sector has become a prime target for cybercriminals. By mid-2024, the US healthcare industry reported 280 cyber incidents, accounting for 24% of all breaches across sectors. The consequences are severe: financial losses, legal battles, and a significant erosion of patient trust, leading to long-term implications for healthcare providers. 

In April 2024, Mega Health Systems, a major U.S. healthcare provider, suffered a sophisticated ransomware attack. Attackers encrypted vital patient records and demanded a hefty ransom. After prolonged negotiations, Mega Health paid the ransom, but when factoring in system restoration, cybersecurity enhancements, legal fees, and settlements, the breach’s total cost reached a staggering $250 million. 

The UK has also faced significant challenges. In July 2024, the National Health Service (NHS) experienced a severe breach compromising over 12 million patient records, including personal information, medical histories, and treatment details. This breach caused widespread chaos in hospitals and clinics, delaying patient care. The response and recovery efforts cost over £100 million and significantly damaged the NHS’s reputation, leaving patients questioning the security of their personal health information. 

These incidents are just the tip of the iceberg. Many organizations do not report security breaches, but it’s estimated that the total cost of healthcare-related security incidents in the US and UK this year could approach $9 billion.   

The Often-Overlooked Healthcare Vulnerability: Unpatched Third-Party Software 

Given the scale of these threats, you might wonder why Recast Software, not typically seen as a security vendor, is discussing cybersecurity. The reality is that IT teams are often at a disadvantage when facing these threats. 

One often overlooked attack vector is unpatched third-party software—a vulnerability Liquit Workspace addresses exceptionally well. Liquit Workspace’s release and patch management capabilities can help IT teams prevent this easily exploitable vulnerability, which is common in many organizations. 

The number of attack vectors is vast, and IT teams can only do so much to protect organizations. This is especially true when considering that many organizations operate on shoestring budgets and with ever-decreasing staff levels.   

Liquit Workspace: A Comprehensive Solution for Application Management 

Liquit Workspace is the leading end-to-end application management platform, designed to deliver, configure, update, and manage applications dynamically throughout their lifecycle. It ensures your applications, whether on Windows or Mac, are always up-to-date and secure. 

In the UK, the Cyber Essentials certification recommends updating applications within 14 days of a vendor releasing a patch for a critical vulnerability. This can be challenging, requiring organizations to identify which applications are in their estate, assess known vulnerabilities, and determine if a vendor has released a patch. Liquit Workspace simplifies this process by enabling IT teams to automatically deploy updates across hundreds or thousands of endpoints as soon as they are available. 

Liquit’s ability to automate the patching and updating of third-party applications is a game-changer for many organizations. By reducing the time to patch vulnerabilities to under 24 hours, Liquit helps organizations close security gaps quickly and efficiently, ensuring all applications remain secure and up to date. Liquit supports both legacy and modern applications, virtual applications, custom applications, and more. This flexibility makes Liquit an indispensable tool for healthcare organizations navigating the complexities of hybrid environments. 

Beyond Patch Management in Healthcare 

Liquit Workspace goes beyond patch management, providing detailed telemetry on user interaction with the application estate. IT teams can monitor application launches, track installation successes or failures, and oversee patch distribution—all in real-time. 

Additionally, features like Smart Icons guarantee a consistent user experience across all devices while seamlessly integrating with existing IT infrastructure. Our Smart Icon Technology further elevates this experience by offering dynamic, context-sensitive icons that adapt to user roles, device types, network conditions, and location. This ensures users are always presented with relevant, up-to-date information. For instance, icons can change depending on access context, reflect updates or maintenance, and be customized to indicate application priority or alerts related to its usage.  

Liquit’s bootstrapper also integrates with Microsoft Intune and Autopilot, enhancing application deployment and management across enterprise environments. By leveraging Liquit’s powerful automation capabilities, organizations can streamline software deployment to devices managed through Intune and Autopilot, ensuring consistent application delivery and reducing manual configuration efforts. This integration simplifies endpoint management by enabling IT teams to pre-configure applications and settings automatically during device provisioning, resulting in a more efficient and user-friendly setup process. 

Real-World Applications and Case Studies 

Liquit’s impact is not just theoretical—it’s proven in real-world applications. For instance, Liquit has transformed IT operations at Dagelijks Leven, a Dutch healthcare organization with over 2,500 employees across 75 locations. The implementation of Liquit Workspace has automated application management, including patching, and provided consistent, secure access to necessary tools. This automation is a boon for the small IT team, reducing their workload and enabling them to efficiently manage all devices and applications. The productivity gains have allowed them to focus on enhancing patient care while ensuring all systems remain up-to-date and secure. 

This case exemplifies how Liquit can streamline application management and enhance the user experience in even the most challenging environments. Explore more case studies and success stories. 

Conclusion: Enhancing Healthcare Cybersecurity with Liquit Workspace  

Healthcare organizations face unique challenges in protecting against security breaches. Integrating Liquit Workspace’s release and patch management into your healthcare IT strategy can significantly enhance your security posture while freeing up IT resources for more strategic initiatives. By addressing one of the major attack vectors—unpatched third-party software—Liquit Workspace offers a powerful tool in the ongoing battle against cyber threats. 

Thank you for reading! For more insights or to schedule a personalized demo with Recast Software, connect with us on LinkedIn or reach out with any questions.  

The post Enhancing Healthcare Cybersecurity: The Crucial Role of Liquit Workspace in Patch Management  appeared first on Recast Software.

Understanding the App-V End-of-Life Transition

In Microsoft’s own official guidance for App-V replacement, they recommend that users transition from App-V to Azure Virtual Desktop and adopt MSIX as their packaging format. This advice seems to be a swing and a miss. The implication here is that all application packaging should now be done in MSIX format, with deployment facilitated through MSIX App Attach.

What Microsoft’s recommendation fails to address are the lingering compatibility issues associated with MSIX. This means that a direct conversion from App-V to MSIX or a complete repackaging of the application into MSIX, will not have a higher success rate.

It’s often necessary to turn to an open-source kit like the Package Support Framework (PSF) or third-party tools such as PsfTooling to tackle these compatibility challenges These solutions provide the much-needed support to ensure a smoother transition and better compatibility when working with MSIX.

Many organizations are still heavily reliant on App-V, which raises questions about the recent push towards MSIX. It seems a bit hasty to recommend such a significant change without providing a thorough explanation of what the transition entails.

These organizations should have a more developed and stable MSIX ecosystem before making such transitions. The proposed go-to-solution should not introduce compatibility issues. Adopting a new technology that is not yet fully refined makes a smooth transition with minimal chances of disruption less likely.

A Smooth Transition for Application Management with Liquit

Many IT professionals are asking for a better solution with those in larger organizations facing the daunting challenge of transitioning their entire software portfolio. App-V and MSIX packaging is complex, time-consuming and costly.

On the bright side, Liquit Workspace, doesn’t require specific packaging knowledge, and the steps below demonstrate how it:

• Makes management effortless
• Translates into computing and storage cost savings with the absence of an App-V infrastructure

it’s still possible to continue using your App-V packages with Liquit after April 2026, which gives your organization the crucial advantage of more time to make a complete transition. This breathing space allows organizations to reassess their application landscape, considering whether repackaging is necessary at all.

As software vendors innovate, alternatives may emerge, like SaaS solutions or native installers that easily adapt to various platforms, including virtual and physical desktops. And if conversion to an App Layering product is the only option, Liquit Workspace has you covered there too. Thanks to our smart-icon technology, users see only the icon they need—today it might be an App-V package, but tomorrow it could just as easily be a native installer. Let’s look at the steps involved in using Liquit for this purpose.

Step-by-Step Guide to Managing the App-V End-of-Life Transition with Liquit

The steps involved in using Liquit as a rescue strategy that ensures a smooth transition for its users as App-V reaches its end-of-life are simple.

Since automation is key to streamlining workflows, you’ll be pleased to know that the steps I’m about to share can be completely automated with a PowerShell Script.

My colleague, Roel van Bueren, is an expert on this topic and has covered it extensively in his insightful blog post on app-v packages. Don’t worry if scripting isn’t your cup of tea, because I’ve laid out the steps below for you to easily follow.

Are you interested in setting up an entire Liquit environment rapidly with just one script? Including adding a number of packages that are automatically created with PowerShell. Look no further! In my upcoming blog post, I’ll guide you through the process step by step. Stay tuned for the details on how to streamline Liquit Workspace administration and boost efficiency.

Step 1: Obtain Information from an App-V Package using Microsoft Application Virtualization Sequencer

For this step, the Microsoft Application Virtualization Sequencer is required. Currently, the App-V Sequencer is part of the Windows Client Assessment and Deployment Kit (Windows ADK).

Step 2: Add an App-V Package in Liquit Workspace

The End Result

Would you like to revisit the steps for adding an App-V package into Liquit Workspace at your leisure? We also have a step-by-step instruction document available.

If you still have questions about how we can assist you, send us an email at transition@recastsoftware.com.

The post App-V End of Life: Your Transition Strategy appeared first on Recast Software.

The Liquit PowerShell module now offers comprehensive license usage information, including: 

• PurchasedType : The type of license purchased. 
• BillableCount: The number of licenses that are billable. 
• PurchasedCount: The total number of licenses purchased. 
• ExcludedCount: Licenses that are excluded from billing. 
• OverUsage: Instances where usage exceeds the purchased licenses. 
• BillableRefreshedAt: The last time the billable data was refreshed. 

These enhancements enable administrators to efficiently manage and monitor their licensing needs. 

Key Features of Liquit License Management Automation 

While this feature is powerful, effectively leveraging the data requires careful consideration. Here’s an overview of key points to keep in mind: 

• Accessing License Information: This can be achieved with a straightforward PowerShell command that retrieves the necessary data. 
• Centralize: Store your data in Azure Blob Storage to centralize and streamline access. Azure Key Vault simplifies the secure management of secrets by centralizing storage. 
• Visualizing Data: To make the data insightful and accessible, consider using data visualization tools like Power BI. Power BI can help you create dashboards and reports that provide a clear overview of your licensing status. 
• Automate: Leverage Azure Automation with a Runbook, PowerShell script, and scheduling to automate the generation of license usage data. 
• Regular Monitoring: Regularly review this data to stay on top of licensing needs and prevent over-usage. 

Enhancing Liquit License Management Automation Using Azure 

When it comes to automating tasks in Azure, security and efficiency are key. That’s where Azure Key Vault becomes a crucial element. Azure Key Vault offers several advantages, particularly relevant to our situation: 

• Enhanced Security: Azure Key Vault enhances security by securely storing sensitive information, such as passwords, tokens, and API keys, eliminating the need to hard-code secrets into scripts. This reduces the risk of exposing critical information. 
• Centralized Management: Azure Key Vault simplifies secret management by centralizing storage across multiple scripts or environments. This allows for easy credential updates without modifying existing scripts, saving time and ensuring consistency across automation processes. 
• Seamless Integration with Azure Automation: Azure Key Vault seamlessly integrates with Azure Automation, allowing scripts to easily retrieve and use stored secrets. This simplifies credential management in automation scripts, minimizing security risks. 

Script Overview 

If you need a powerful PowerShell script to streamline your tasks, you’re in luck. I’ve created a script that you can use right away. Visit my GitHub to download it.  

The PowerShell script I wrote will do the following: 

• Retrieve Liquit credentials and Liquit Workspace URL from Azure Key Vault to use in this PowerShell script 
• Use the Get-LiquitZone to get the Liquit License usage information and write it to a CSV-file with a date stamp in the filename 
• Send it to a container in Azure Blob Storage 

Step-by-Step Guide to Liquit License Management Automation 

To achieve the desired outcome, follow these steps: 

1. Create Azure Storage Account and create a container where the CSV-files can be stored 
2. Create an Azure Key Vault 
   • Create Key Vault Secrets for the Liquit Workspace Credentials and Liquit Workspace URL 
   • Make sure that Storage Account has the correct permissions to access secrets within Azure Key Vault 
3. Create an Azure Automation Account 
   • Install the Liquit PowerShell Module which is available in the PowerShell Gallery in Azure Automation. The module can be found with the name Liquit.Server.PowerShell 
   • Create a Runbook and use the PowerScript I wrote 
   • Add a Schedule to the Runbook 
4. Install Microsoft Power BI Desktop on your device
   • Connecting Azure blob storage data to Microsoft Power BI desktop 
   • Transform multiple CSV files from Blob storage without combining them 
   • Create an awesome cool Dashboard 
   • Publish it online in the Power BI service 

To view and share reports on the Power BI Service and automatic schedule data refreshes, a Microsoft Pro or Premium license is required. 

Benefits of Liquit License Management Automation for IT Operations 

Security and efficiency are crucial. Automating the retrieval of license usage information within Liquit Workspace and integrating it with Azure services simplifies processes and enhances IT operations. 

One of the standout features of this solution is its ability to securely store the output data in a CSV file on Azure Blob Storage. Leveraging Azure Key Vault for credential management eliminates the risks associated with hardcoded credentials, ensuring a secure and compliant environment. 

By scheduling this PowerShell script to run weekly in an Azure Automation runbook, you can ensure that data collection is both consistent and up to date. The gathered data is securely stored in Azure Blob Storage, making it easily accessible for further analysis. 

By connecting Power BI to the data stored in Azure Blob Storage, you can create a dynamic, visually appealing dashboard. This dashboard not only empowers IT administrators with vital insights but also serves as a comprehensive reporting solution for IT managers. 

The result is a streamlined, automated workflow that enhances transparency and accountability while delivering a dynamic dashboard with detailed Liquit license usage information. This makes IT operations more efficient and effective than ever. 

If you have any questions, feel free to reach out. Liquit is here to help! 

The post Streamline Liquit License Management Automation with PowerShell, Azure, and Power BI appeared first on Recast Software.

Prerequisites

Before proceeding, ensure that Entra ID is configured as your Identity Source. If not, please follow the instructions at Microsoft Entra ID – Identity Sources to set it up. The steps outlined here were derived from both trial and error and Liquit documentation, particularly the Liquit Agent Bootstrapper deployment with Intune. While these are the steps I followed, your environment may require different settings and customizations. Please consult the documentation for a complete list of settings for your JSON file.  

Note: This guide focuses on configuring the Liquit bootstrapper and agent settings, not Autopilot. 

The term ‘Deployments’ can be ambiguous in IT contexts. For this guide, ‘Deployments’ refers specifically to the section in the Liquit server labeled ‘Deployments.’ 

Step-by-Step Guide to Liquit Deployments through Intune 

Begin by logging into your Liquit portal. We’ll start by configuring and downloading the necessary components. First, create your deployment, which is a collection of packages you intend to deploy to a machine during agent installation. 

• Create your deployment in Liquit. 
  • In Liquit > Manage > Deployments. 
    • Click Create. 
    • Enter a name for your deployment and Click Next. 

• Click Finish
• Once the properties load, proceed with the following steps. 
  • Click Packages. 
  • Search for and add any packages that you would like for this deployment, be sure to specify the “Install” action.

• Click Assignments.
• Be sure to add an assignment for All Devices and the Production Stage.

Now we will move on to getting the certificates needed for the agent installation. 

Certificates for Liquit Deployments

• Certificate-based registration is recommended for optimal device registration. The following steps ensure a smooth process. 
  • In Liquit < Manage < Device Registration, follow the below steps: 
    • Click Create. 
    • Keep the “Certificate” section highlighted and click Next. 

• Name your Certificate and click Next.

• Select the box for Use a self-signed certificate for device registration and click Next.

Give your certificate a name, validity period, and key size. If desired, add a description, then click Next.

• Click Finish. 
• When the properties come up, click on Settings. 
• On the right-hand side, click the button for Download for agent registration button.

• Save this file for use when creating the Intunewin file. 
• Export out the three certificates from the Liquit Server and Certificate Management. This may be different from your environment. We need to establish that trust chain between your client and our Liquit server. 
  • IIS Cert you used. 
  • CA Cert for that IIS Cert. 
  • Liquit Self-Signed Cert. 
• Create three profiles in Intune, one that pushes out the above three certs to devices in their root store Create trusted certificate profiles in Microsoft Intune | Microsoft Learn. 

Download and Create Required Files

• Create a folder on your C:\ drive (or any folder you choose) to store all the downloaded files. 
• Navigate to Support – Liquit and download the Agent Bootstrapper and save it in the above folder. 
• Log in to your Liquit server and click on your user picture in the right-hand corner and click the link to download the agent. Once downloaded, save to above folder, and rename to Agent.exe. 
• Copy the downloaded certificate file from above to the same folder. 
• Use Notepad++ (or your choice of editor) to create a Json file named “agent.json” and save it to that same folder. 
• Create your Json file. At the end of this document is the Json file that I used that you could copy and modify according to your own settings. I’ve highlighted the areas that require modification. Review the remaining settings to determine if further customization is needed. 
  • The Zone will be your zone that you have created. 
  • The certificate thumbprint will be from the certificate you downloaded in Step 1. 
  • The deployment will be the name of the deployment you created in Step 2. 
  • The identity source will be the name of the Identity source you have created for SSO.  
  • The trusted zone is where you would enter your zone name. This can be multiple zones if you have more than one. 
• Create your IntuneWin file and create your app in Intune. 
  • Follow the documentation guide from Liquit Agent Bootstrapper deployment with Intune to create and upload your package to Intune. 
  • Add ‘/certificate=”AgentRegistration.cer”’ to the install command line so that it copies the certificate you uploaded into the right location so that agent can register correctly with Liquit. 
  • Change the command line for the log to a location that is easily accessible. I used C:\Windows\Temp as my log file location. 
  • Modify the detection method so that instead of using the provided script, you hard code it to look in c:\Program Files\Liquit Universal Agent. 
  • Deploy as required to your autopilot or other devices. 

Achieving a Functional Autopilot Deployment with Liquit Deployments through Intune 

By following these instructions, you should achieve a fully functional Autopilot deployment of applications during device provisioning or initial agent installation.

Note: Ensure port 443 is open on your Liquit server to facilitate communication with clients. After deployment, a device reboot is required to allow the agent to exit deployment mode and restart as a normal process. 

Additional Note: This guide focuses on deploying Liquit on Windows devices. A separate guide for deploying on macOS devices will be published soon.

Happy deploying! 

{ 
    "zone":"https://liquit.corp.viamonstra.com", 
	"promptZone": "Disabled", 
    "registration": { 
        "type": "Certificate", 
		"certificateThumbprint": "1f319334a7357653ded039659953e600e31e6d0f" 
    }, 
    "log": { 
        "level": "Debug", 
		"agentPath": "C:\\Windows\\Temp\\Agent.log", 
		"userHostPath": "C:\\Windows\\Temp\\UserHost.log", 
		"rotateCount": 5, 
		"rotateSize": 1048576 
    }, 
    "deployment": { 
        "enabled": true, 
        "start": true, 
        "context": "device", 
        "cancel": true, 
        "triggers": false, 
        "autoStart": { 
            "enabled": true, 
            "deployment": "Autopilot", 
            "timer": 0 
        } 
    }, 
	"login": { 
		"enabled": true, 
		"sso": true, 
		"identitySource": "MadduxConsulting", 
		"timeout": 4 
	}, 
	"icon": { 
		"enabled": true, 
		"exit": false, 
		"timeout": 30 
	}, 
	"launcher": { 
		"enabled": true, 
		"state": "Default", 
		"start": "Auto", 
		"tiles": true, 
		"minimal": false, 
		"contextMenu": false, 
		"sideMenu": "Tags", 
		"close": true 
	}, 
	"restrictZones": true, 
	"trustedZones": [ 
		"liquit.corp.viamonstra.com" 
	] 
} 

The post How to Create and Provision Liquit Deployments through Intune  appeared first on Recast Software.

I saw this as a wonderful challenge to tackle and decided to write a blog about it. The idea of simplifying the initial setup of Liquit Workspace through a guided setup script immediately sparked my interest. It’s not just about making things easier. It’s also about transforming the way we approach configuration and automation.  

Why Automation is Key: Rapid Liquit Configuration

There are several reasons why automation is essential for IT today. Here are, in my opinion, some of the most important ones: 

• Increased Demands: The ever-growing demands on IT infrastructure require efficient solutions. Automation allows IT professionals to save valuable time and resources. 
• Efficiency and Consistency: Automation completes tasks faster and more accurately, reducing the risk of human error and ensuring consistent configurations. This results in increased productivity and improved quality. 
• Standardization: Provides a more standardized way of configuring that can be executed across multiple systems, in our case, Liquit Workspace Zones. This ensures that every Liquit Workspace environment is set up in the same way, for example, with a certain naming convention in the packages, etc. 
• Innovation: By automating repetitive tasks, IT teams have more time to innovate and adapt to new technologies.  

Using our Liquit PowerShell Module is an excellent choice for configuring Liquit Workspace environments. Liquit Workspace PowerShell module provides access to a rich set of cmdlets (commands) that allow you to control various aspects of an Liquit Workspace environment.  

Interested in learning more? Dive into all the details about our PowerShell module at Liquit PowerShell Module Documentation. 

The Grail PowerShell Script: A Step-by-Step Guide

This magical PowerShell script is available to view or download here, as promised in my earlier blog post “App-V EOL: Liquit Your Rescue Strategy”. I’ve intentionally included a couple of Smart Icon examples within this PowerShell script. Check out the PowerShell code for more details. 

• First example Smart Icon: Microsoft Power BI Desktop 
  • Script lines 330 to 414 
• Second example Smart Icon: XCP-ng Center (App-V) 
  • Script lines 416 to 557 

This PowerShell script will use a form to ask a series of questions and then proceed to configure the following settings: 

1. Add a New Liquit Identity Source for Microsoft Entra ID (Azure AD) and update 
2. Hide the Local Liquit Identity Source 
3. Create some example packages which include:  
   • Multiple Launch (Smart Icons) packages 
   • A Package from the Liquit Setup Store 
   • A URL Package 
   • Custom Packages (MSI & EXE) 
   • App-V Package 
   • MSIX Package 
4. Create an example Tag and set the tag  
5. Create a connector to the Liquit Setup Store with all the new settings available since the Release of Liquit Workspace version 4.2. Such as the macOS and Portable applications and Include uninstall actions 
6. Create Scheduled Tasks to automatically update apps or notify to a specific email address when updates are available 
7. Create a Custom Access Policy 
8. Set Liquit User Permissions for a Entra group to the new created Custom Access Policy 
9. Set Liquit Admin Permissions for a Entra group  
10. Custom branding by changing User Settings (Background and Workspace Name) & Portal Settings (Company Logo) => The PowerShell script checks whether two files with the specific names below exist in the directory ”C:\Liquit”. 
    • Company_background.png 
    • Company_logo.png

PowerShell Script Note: It’s a foundational script, meaning there’s plenty of room for improvement, such as adding more control checks or refining the code itself. This script can serve as a guideline and can be adapted to meet the specific needs and requirements of your organization. I hope it evolves into a community-driven script where everyone can contribute. Personally, I hope it can become a community project. 

Revealing the Outcome: Demo Video

In this video, I will demonstrate all the steps needed how to set up a new Liquit Workspace using the PowerShell script. All settings will be applied as described in this blog. 

Conclusion: Automating Liquit Configuration

Due to the increasingly higher demands placed on IT, where every minute counts, automating your Liquit Workspace with PowerShell can help you achieve a fully configured environment in short order. While it requires preparation and knowledge of the right PowerShell cmdlets, once everything is set up, you can complete the entire configuration for a Liquit Workspace environment in about a minute! Allowing IT-professionals to focus on more complex challenges. 

Do you have questions we can assist with? Want to learn more by talking with our team? Feel free to reach out to us. We’re always ready to help! 

The post Liquit Automation: Setup Done in 60 seconds appeared first on Recast Software.

Introduction to PuTTY and App-V Package Deployment

In this blog, I’ve used an App-V package for PuTTY created using Liquit Setup Commander and the App-V Sequencer. The latter used to be part of MDOP and is now part of the Windows 10 Assessment and Deployment Toolkit (Windows ADK).

To simplify creating a Liquit Workspace package for an App-V package of PuTTY, I’ve included a PowerShell script at the end of this blog.

This PowerShell script can be changed easily. To use it with any App-V package, you would want to distribute and use it from within Liquit Workspace. It creates a Smart Icon with all actions needed to enable App-V, publish, unpublish, and remove the App-V package for PuTTY, as demonstrated in this video.

The actions which are used to support App-V have been divided into Install, Launch, and Uninstall action sets.

Install

• Upload PuTTY 0.73.appv
  
  This action copies ‘PuTTY 0.73.appv’ to ${PackageTempDir}PuTTY 0.73.appv. This directory translates to %LOCALAPPDATA%Temp.
  
• Enable-Appv
  
  This action uses the Enable-Appv cmdlet to enable the Microsoft Application Virtualization (App-V) service on Windows 10 Enterprise or Education 1607 and up.
  
• Add-AppvClientPackage | Mount-AppvClient
  
  This action uses the Add-AppvClientPackage cmdlet to add the App-V application per device on devices which have App-V enabled.
  
• Mount-AppvClientPackage (not shown in the video)
  
  This action uses the Mount-AppvClientPackage cmdlet to load the package into the App-V cache on devices which have App-V enabled.
  
• Publish-AppvClientPackage
  
  This action uses the Publish-AppvClientPackage cmdlet to publish the application for all users of a device.

Start Normal PuTTY

If needed, you can enable this action to launch PuTTY in a normal way for devices on which App-V is not supported, like Windows 10 Home Edition. To install PuTTY this way (without App-V), you would need to add an ‘Install package’ action that references a managed package from the Setup Store to the Install action set. However, this process is beyond the scope of this blog, as I am focusing solely on using App-V.

Start App-V PuTTY

After the App-V application has been published, the application is available as App-VE1D03455-9A27-4E26-BF4E-CAA2F2DD8A239980FADE-CD94-4C81-B9B2-32F8FF2BCACCRootVFSProgramFilesX86PuTTYputty.exe in the All Users Profile directory. A filter to check for ${AllUsersProfile}App-VE1D03455-9A27-4E26-BF4E-CAA2F2DD8A239980FADE-CD94-4C81-B9B2-32F8FF2BCACCRootVFSProgramFilesX86PuTTYputty.exe has been added to make sure it’s only started when it has been published

Unpublish-AppvClientPackage PuTTY

This action uses the Unpublish-AppvClientPackage cmdlet to unpublish the published App-V application for all users of a device.

Remove-AppvClientPackage PuTTY

This action uses the Remove-AppvClientPackage cmdlet to unpublish the published App-V application for all users of a device.

PowerShell Script for PuTTY App-V Package Deployment

Import-Module "C:Program Files (x86)Liquit WorkspacePowerShell3.0Liquit.Server.PowerShell.dll" -Prefix "Liquit"

[System.Reflection.Assembly]::LoadWithPartialName(“System.IO.Compression”) | Out-Null;
[System.Reflection.Assembly]::LoadWithPartialName(“System.IO.Compression.FileSystem”) | Out-Null;

$liquitZoneUsername = "localadmin"
$liquitZonePassword = Read-Host "Enter Password" -AsSecureString
$liquitCredentials = New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $liquitZoneUsername, $liquitZonePassword
$liquitZone = "https://yourliquitzone.liquit.com"

$puttyIconURL = "https://www.setupcommander.com/ico/putty.ico"
$puttyIconPath = "c:windowstempputty.ico"
$puttyAppVPackagePath = "c:packagesPuTTY 0.73.appv"
$puttyAppVPackageFilename = "PuTTY 0.73.appv"

#get the Version ID and Package ID of the App-V package
$AppxManifestPath = "c:windowstempappxmanifest.xml"
$AppV5Package = New-Object System.IO.Compression.ZipArchive(New-Object System.IO.FileStream($puttyAppVPackagePath, [System.IO.FileMode]::Open));
$AppxManifest = $AppV5Package.GetEntry(“AppxManifest.xml”);
[System.IO.Compression.ZipFileExtensions]::ExtractToFile($AppxManifest, $AppxManifestPath, $true);
$xml = [xml](Get-Content $AppxManifestPath)
$AppV5PackageVersionId = $xml.Package.Identity.VersionId.ToUpper() 
$AppV5PackageId = $xml.Package.Identity.PackageId.ToUpper()
$AppV5Version = $xml.Package.Identity.Version
$AppV5DisplayName = $xml.Package.Properties.DisplayName
$AppV5Package.Dispose();

#connect to Liquit Workspace
$liquitContext = Connect-LiquitWorkspace -URI $liquitZone -Credential $liquitCredentials

#download the icon
$webClient = New-Object System.Net.WebClient
$webClient.DownloadFile($puttyIconURL,$puttyIconPath)
$iconContent = New-LiquitContent -Path $puttyIconPath

#define and create the package 
$packageName = "PuTTY"
$packageDisplayName = "PuTTY"
$packageDescription = "PuTTY"

$package = New-LiquitPackage -Name $packageName `
                             -Type "Launch" `
                             -DisplayName $packageDisplayName `
                             -Description $packageDescription `
                             -Priority 100 `
                             -Enabled $true `
                             -Offline $True `
                             -Web $false `
                             -Icon $iconContent

#create the snapshot for this package
$snapshot = New-LiquitPackageSnapshot -Package $package

#define install action set
$actionset_install = New-LiquitActionSet -snapshot $snapshot `
                                 -Type Install `
                                 -name 'Install' `
                                 -Enabled $true `
                                 -Frequency Always `
                                 -Process Sequential


#
#define the first install action
$actionset_install_action1 = New-LiquitAction -ActionSet $actionset_install `
                                      -Name 'Copy uploaded App-V Package to local' `
                                      -Type 'contentcopy' `
                                      -Enabled $true `
                                      -IgnoreErrors $false `
                                      -Settings @{content = $puttyAppVPackageFilename; destination = '${PackageTempDir}' + $puttyAppVPackageFilename} `
                                      -Context Device

$appvContent = New-LiquitContent -Path $puttyAppVPackagePath -FileName $puttyAppVPackageFilename
$attribute = New-LiquitAttribute -Entity $actionset_install_action1 -Link $appvContent -ID 'content' -Settings: @{filename = $puttyAppVPackageFilename}


#
#define the second install action
#
$actionset_install_action2 = New-LiquitAction -ActionSet $actionset_install `
                                      -Name 'Enable-Appv' `
                                      -Type 'contentscript' `
                                      -Enabled $true `
                                      -IgnoreErrors $false `
                                      -Settings @{content = 'script.ps1'; type = 3; display = 1; engineParameters = "-NoLogo -ExecutionPolicy Bypasss"; successReturnCodes = 0, 1} `
                                      -Context Device

#add the PowerShell script for this action
$scriptLine = 'Enable-Appv'
Set-Content -Path 'c:windowstempscript.ps1' -Value $scriptLine
$script_content_actionset_install_action2 = New-LiquitContent -Path "c:windowstempscript.ps1" -FileName 'script.ps1'
$attribute = New-LiquitAttribute -Entity $actionset_install_action2 -Link $script_content_actionset_install_action2 -ID 'script' -Settings: @{filename = 'script.ps1'}

#
#define the third install action
#
$actionset_install_action3 = New-LiquitAction -ActionSet $actionset_install `
                                      -Name 'Add-AppvClientPackage' `
                                      -Type 'contentscript' `
                                      -Enabled $true `
                                      -IgnoreErrors $false `
                                      -Settings @{content = 'script.ps1'; type = 3; display = 1; engineParameters = "-NoLogo -ExecutionPolicy Bypasss" ; directory = '${PackageTempDir}'; successReturnCodes = 0, 1} `
                                      -Context Device

#add the PowerShell script for this action
$scriptLine = 'Add-AppvClientPackage "' + $puttyAppVPackageFilename + '"'
Set-Content -Path 'c:windowstempscript.ps1' -Value $scriptLine
$script_content_actionset_install_action3 = New-LiquitContent -Path "c:windowstempscript.ps1" -FileName 'script.ps1'
$attribute = New-LiquitAttribute -Entity $actionset_install_action3 -Link $script_content_actionset_install_action3 -ID 'script' -Settings: @{filename = 'script.ps1'}


#
#define the fourth install action
#
$actionset_install_action4 = New-LiquitAction -ActionSet $actionset_install `
                                      -Name 'Mount-AppvClientPackage' `
                                      -Type 'contentscript' `
                                      -Enabled $true `
                                      -IgnoreErrors $false `
                                      -Settings @{content = 'script.ps1'; type = 3; display = 1; engineParameters = "-NoLogo -ExecutionPolicy Bypasss" ; directory = '${PackageTempDir}'; successReturnCodes = 0, 1} `
                                      -Context Device

#add the PowerShell script for this action
$scriptLine = 'Mount-AppvClientPackage "' + $puttyAppVPackageFilename + '"'
Set-Content -Path 'c:windowstempscript.ps1' -Value $scriptLine
$script_content_actionset_install_action4 = New-LiquitContent -Path "c:windowstempscript.ps1" -FileName 'script.ps1'
$attribute = New-LiquitAttribute -Entity $actionset_install_action4 -Link $script_content_actionset_install_action3 -ID 'script' -Settings: @{filename = 'script.ps1'}


#
#define the fifth install action
#
$actionset_install_action5 = New-LiquitAction -ActionSet $actionset_install `
                                      -Name 'Publish-AppvClientPackage' `
                                      -Type 'contentscript' `
                                      -Enabled $true `
                                      -IgnoreErrors $false `
                                      -Settings @{content = 'script.ps1'; type = 3; display = 1; engineParameters = "-NoLogo -ExecutionPolicy Bypasss" ; directory = '${PackageTempDir}' ; successReturnCodes = 0, 1} `
                                      -Context Device

#add the PowerShell script for this action
$scriptLine = 'Publish-AppvClientPackage -Name "' + $AppV5DisplayName + '" -Global'
Set-Content -Path 'c:windowstempscript.ps1' -Value $scriptLine
$script_content_actionset_install_action5 = New-LiquitContent -Path "c:windowstempscript.ps1" -FileName 'script.ps1'
$attribute = New-LiquitAttribute -Entity $actionset_install_action5 -Link $script_content_actionset_install_action5 -ID 'script' -Settings: @{filename = 'script.ps1'}

#define launch action set
$actionset_launch = New-LiquitActionSet -snapshot $snapshot `
                                 -Type Launch `
                                 -name 'Launch' `
                                 -Enabled $true `
                                 -Frequency Always `
                                 -Process StopAtFirstEffectiveAction
#
#define the first launch action
#
$actionset_launch_action1 = New-LiquitAction -ActionSet $actionset_launch `
                                      -Name 'Start Normal PuTTY' `
                                      -Type 'processstart' `
                                      -Enabled $false `
                                      -IgnoreErrors $false `
                                      -Settings @{name = '${ProgramFiles32}PuTTYputty.exe'; parameters = "";} `
                                      -Context User

#define the filter set for the first launch action
$filterset_launch_action1 = New-LiquitFilterSet -Action $actionset_launch_action1

#add a filter to the first action
$filter_launch_action1 = new-LiquitFilter -FilterSet $filterset_launch_action1 -type fileexists -Settings @{path = '${ProgramFiles32}PuTTYputty.exe';} -Value "true" 

#
#define the second launch action
#
$actionset_launch_action2 = New-LiquitAction -ActionSet $actionset_launch `
                                      -Name 'Start App-V PuTTY' `
                                      -Type 'processstart' `
                                      -Enabled $true `
                                      -IgnoreErrors $false `
                                      -Settings @{name = '${AllUsersProfile}App-V' + $AppV5PackageId + '' + $AppV5PackageVersionId + 'RootVFSProgramFilesX86PuTTYputty.exe'; parameters = "";} `
                                      -Context User

#define the filter set for the second launch action
$filterset_launch_action2 = New-LiquitFilterSet -Action $actionset_launch_action2

#add a filter to the second action
$filter_launch_action2 = new-LiquitFilter -FilterSet $filterset_launch_action2 -type fileexists -Settings @{path = '${AllUsersProfile}App-V' + $AppV5PackageId + '' + $AppV5PackageVersionId  + 'RootVFSProgramFilesX86PuTTYputty.exe';} -Value "true" 


#define uninstall action set
$actionset_uninstall = New-LiquitActionSet -snapshot $snapshot `
                                 -Type Uninstall `
                                 -name 'Uninstall' `
                                 -Enabled $true `
                                 -Frequency Always `
                                 -Process Sequential
#
#define the first uninstall action
#
$actionset_uninstall_action1 = New-LiquitAction -ActionSet $actionset_uninstall `
                                      -Name 'Unpublish-AppvClientPackage PuTTY' `
                                      -Type 'contentscript' `
                                      -Enabled $true `
                                      -IgnoreErrors $false `
                                      -Settings @{content = 'script.ps1'; type = 3; display = 1; engineParameters = "-NoLogo -ExecutionPolicy Bypasss"} `
                                      -Context Device

#add the PowerShell script for this action
$scriptLine = 'Unpublish-AppvClientPackage -Name "' + $AppV5DisplayName + '" -Version ' + $AppV5Version + ' -Global'
Set-Content -Path 'c:windowstempscript.ps1' -Value $scriptLine
$script_content_actionset_uninstall_action1 = New-LiquitContent -Path "c:windowstempscript.ps1" -FileName 'script.ps1'
$attribute = New-LiquitAttribute -Entity $actionset_uninstall_action1 -Link $script_content_actionset_uninstall_action1 -ID 'script' -Settings: @{filename = 'script.ps1'}

#
#define the second uninstall action
#
$actionset_uninstall_action2 = New-LiquitAction -ActionSet $actionset_uninstall `
                                      -Name 'Remove-AppvClientPackage PuTTY' `
                                      -Type 'contentscript' `
                                      -Enabled $true `
                                      -IgnoreErrors $false `
                                      -Settings @{content = 'script.ps1'; type = 3; display = 1; engineParameters = "-NoLogo -ExecutionPolicy Bypasss"} `
                                      -Context Device

#add the PowerShell script for this action
$scriptLine = 'Remove-AppvClientPackage -PackageId ' + $AppV5PackageId.Tolower() + ' -VersionId ' + $AppV5PackageVersionId.ToLower()
Set-Content -Path 'c:windowstempscript.ps1' -Value $scriptLine
$script_content_actionset_uninstall_action2 = New-LiquitContent -Path "c:windowstempscript.ps1" -FileName 'script.ps1'
$attribute = New-LiquitAttribute -Entity $actionset_uninstall_action2 -Link $script_content_actionset_uninstall_action2 -ID 'script' -Settings: @{filename = 'script.ps1'}


#publish the package
Publish-LiquitPackageSnapshot -Snapshot $snapshot -stage Production 

#set the entitlement
$identity = Get-LiquitIdentity -id "LOCALeveryone"
New-LiquitPackageEntitlement -Package $package -Identity $identity -Publish Workspace

App-V Note

App-V is only supported on Windows 10 Education and Enterprise. If you use Windows 10 Home or Professional in your organization, you can filter to the Install and Uninstall action sets. The two filters below can be used to check for ‘Windows 10.0 and the value of the CompositionEditionID in the registry, which is ‘Enterprise’ when Windows 10 Enterprise is used:

Conclusion and Next Steps

By following these steps, you can efficiently create and deploy a PuTTY App-V package in Liquit Workspace, streamlining your application management process. The provided PowerShell script simplifies the deployment, ensuring a smooth integration and optimal performance. For further insight or support, refer to the detailed documentation and resources available within Liquit Workspace.

The post Creating and Deploying a PuTTY App-V Package in Liquit Workspace appeared first on Recast Software.

VDI, DaaS, and Cloud Shift

Application management, UEM, security, and hybrid work are integral parts of the current EUC shift. However, VDI, DaaS, and cloud technologies are emerging as foundational components, supported by recent statistics.^{1, 2} While VMware, Citrix, and Microsoft are all leaders in the DaaS market, Gartner estimates that Microsoft is the largest vendor in this space.³

Citrix and VMware are undergoing significant shifts in their DaaS, VDI, and platform offerings, driven by their respective acquisitions by Tibco and Broadcom. These changes have included a mix of perpetual and universal licensing updates, the selloff of parts of their EUC portfolios, and major layoffs.

These changes, among others, are driving a hybrid cloud shift as more companies turn to Microsoft for SaaS, DaaS, and endpoint management (Intune). Citrix and VMware’s mergers and acquisitions (M&A), along with ongoing changes in Microsoft’s product offerings, could lead to major long-term improvements for customers. However, the challenge for these and other major platform vendors lies in closing the remaining gaps in delivering the modern workspace. These shifts in the VDI/DaaS EUC space take control out of customers’ hands in several ways:

• Companies with on-premises solutions prefer to make the shift on their own schedules rather than being forced into it.
• Many are assessing transitions and migrations based on factors like cost, time, and the best options for stability and future agility.
• There is no seamless way to integrate these solutions without friction and complexity.

Hybrid solutions, such as those from vendors like Parallels and Dizzion (who acquired Frame from Nutanix),⁴ aim to bridge these gaps. However, these changes only add to the uncertainty faced by EUC end users who must navigate transitions between vendors in the VDI/DaaS space. Many of these customers are now wondering why they didn’t concentrate on the device for application, access, and control rather than expensive VDI.

UEM, App Management, and Platform Transition Shift

This shift is characterized by a loss of control and options. Microsoft’s upcoming end of life for Windows 10 is likely to pose significant challenges for many companies in the EUC space, particularly regarding version compatibility.⁵ Microsoft looks to be the clear global market dominating player for cloud EUC. But their mature services contrast with recent changes like Intune across UEM, which brings its own OS and other compatibility challenges across EUC.

Security Shift

A major issue in this shift is the persistent gaps in applications, devices, and security, despite EUC end-users implementing multiple platforms and workspace solutions simultaneously. Application management and UEM are on the front lines of these shifts as delivery, authentication, packaging, versioning, and access management become challenges across different platforms.

The US and Europe see the need for greater security across device landscapes, platforms, enterprise architectures, networks, cloud, and hybrid/on-premises environments. This current shift calls for a major increase in predictive and proactive solution investment rather than the standard reactive approach because of growing cryptoware/ransomware threats.

Platform and UEM Shift

This all takes place as organizations look at migrating or transitioning from one platform to another (Citrix, Nutanix and/or VMware to AVD), along with the need to provide applications across different OS, platforms, and devices. UEM, through growing solutions like Intune via Azure AD, is ushering in new ways of authentication. But in some ways, it hasn’t been the panacea that everyone hoped for as complexities and compatibility slows progress for end users and vendors.

The gaps in UEM and application management all make for a lot of disconnect and authentication concerns across a hybrid cloud, work, and platform landscape. The differences in European and US markets have a lot to do with how each country deals with this broader shift.

US and Europe: Differences in Market Approach

European adoption of Intune has happened quickly, but the size of companies and the channel market ecosystem have made that a smoother transition. This points to a major difference between the US and European markets in terms of their ability to innovate and adopt new technologies faster while avoiding the uncertainty and chaos that shifts can bring.

The US market is a more vendor-direct ecosystem that:

• Is dominated by a focus and landscape of much larger enterprises.
• Has far more complexity where vendors often go for incremental quick wins rather than larger, slow-burn ecosystem rollouts of an entire line of connected solutions.
• Leads to a faster but smaller income infusion (comparatively).
• Requires vendors to almost exclusively focus on reactively solving present pain points, making them less poised for proactive future innovation.

We can see this lack of focus on proactive innovation and agility in the response to the pandemic and remote-work shift in the US. Companies and vendors were forced to cobble together technologies and solutions as stopgaps.

Europe has a more dominant channel market ecosystem that is:

• Driven by more SMEs and fewer massive enterprises like the US
• More capable of faster vendor innovation and greater agility based on creating long-term relationships that foster product suite implementations over time
• Focused on bigger deals with long-term incremental rollout of solution suites based on potential and proven needs, so initial payouts are more conservative but long-term profits are much higher

The Broader Shift to Application and Device Consumption On-Demand

Companies like Apple exemplify the concept of digital experience (DEX) and user control. Apple has developed a DEX that puts the end user in the driver’s seat, allowing transparent access and security for any application on any device. However, it’s the backend control that makes this possible, and vendors in the broader EUC space are beginning to follow suit.

The on-demand DEX world requires solutions that enable that ability without thinking. Technology is a means to an end, so it must be a transparent UX on the front end and technologically flexible, agile, automated, and integrated on the back end. Vendors must stop asking silly questions of end users and just make it work logically to give them the control they need on the front end, because the world is complex enough.

Device enrollment application population, and security must go from taking hours to being instant and transparent to meet end-user demands, which requires:

• More vendor collaboration and integration where possible
• Automation to make things more seamless, simple, and flexible
• Agile technology solutions that make it easy to blend all the different platforms, environments, architectures, devices, and applications on the back end

This consumption on demand world has prompted Microsoft to change the look and feel of Microsoft Intune to be more understandable for end users and IT. Some vendors know what to do, and those that don’t make the shift will not survive.

Recast Software and Liquit: A Future-Proof Model Beyond Every Shift

The future of Liquit that is now part of Recast Software, mirrors the possibility for future-proof agility, flexibility, and innovation. They can do this while delivering consistency and scalability regardless of shifting needs in EUC across the US, Europe, and beyond.

With the addition of the Liquit platform to their global offering, Recast Software now represents a microcosm of the US and European market approaches—vendor-to-company and vendor-to-channel. We collectively understand that meeting EUC needs and navigating current and future shifts requires vendors to move along these two paths simultaneously.

The goal is to be agile enough to do whichever is best for any market, client, or scenario. This requires vendors to empower IT with solutions delivering a consistent foundation that can quickly and cost effectively adapt in a future-proof way to changing needs.

We are pointing the way to that new paradigm by showing that it’s not one way or the other on a market or technology level. Recast Software and Liquit part of Recast Software are moving towards empowering their unified team to think, innovate, integrate, and collaborate on behalf of the customer in service to the present and future shifts. This means looking beyond a focus on Microsoft, VMware, Citrix, and other platforms to a broader picture.

The EUC shift is happening now, and past realities are no longer universally true and consistent. Yesterday it was Citrix, and five years ago it was something else. Today, Microsoft has made tremendous changes, but tomorrow will require even more changes for them and every other vendor.

Bibliography

1. Worldwide spending for public cloud DaaS expected to top 3.5B in 2024, according to Statista. Other statistics put that number well above $6B.
2. The global virtual desktop infrastructure market is expected to grow from $13.81 billion in 2022 to $16.17 billion in 2023 at a compound annual growth rate (CAGR) of 17.1%. The virtual desktop infrastructure market is expected to grow to $30.63 billion in 2027 at a CAGR of 17.3%. This is according to the Research and markets “Virtual Desktop Infrastructure Global Market Report 2023” as reported by Yahoo Finance News.
3. according to the latest Gartner Magic Quadrant for Desktops as a Service.
4. https://www.prnewswire.com/news-releases/dizzion-acquires-frame-from-nutanix-to-accelerate-growth-in-daas-market-301842568.html#:~:text=DENVER%2C%20June%206%2C%202023%20%2F,Nutanix%20(NASDAQ%3A%20NTNX)
5. Windows 10 and 11 https://www.zdnet.com/article/hoping-for-a-windows-10-support-extension-microsoft-just-quietly-crushed-your-dreams/
6. Why the end of Windows 10 could be a big problem https://www.youtube.com/watch?v=M7N–Zf-Ypo

The post In the Future World of EUC, Shifts Happen appeared first on Recast Software.

I really appreciate the FSLogix App Masking feature within the Microsoft FSLogix suite, which works exceptionally well on Azure Virtual Desktop (AVD) session hosts when integrated with Microsoft Entra. But what happens if they are combined with Microsoft Entra alone?

Given that FSLogix has some App Masking limitations, such as the inability to use Microsoft Entra groups when session hosts are joined to Microsoft Entra only, what are the available options? This blog will explain how to use FSLogix App Masking and Microsoft Entra groups with AVD session hosts that are joined to Microsoft Entra only, utilizing Liquit’s capabilities. To do that, we’ll start with a brief overview of FSLogix App Masking. 

Benefits of FSLogix App Masking with Microsoft Entra Integration

FSLogix App Masking allows you to tailor user experiences by hiding specific items—such as files, folders, registry keys, registry values, printers, or fonts—from individual users or user groups. It also gives you the flexibility to define registry values in a unique way for any users applying the “specify value” rule.  

These rule sets can be conveniently assigned to users, groups, or other entities via the Rule Editor. You also have the option to test these rule sets on a test system before implementing them in a production environment. To use FSLogix App Masking, you will need: 

• FSLogix Apps (Core Product) installed on the Azure Virtual Desktop Session hosts where the applications need to be masked. 
• Rules created by the FSLogix Apps Rule Editor. 
• To install the applications to be masked on the Azure Virtual Desktop Session hosts. 

Liquit can handle this through automated deployment or as a Custom Script Extension. You have the green light to use FSLogix if you have the licenses mentioned in the following list: 

• Microsoft 365 E3/E5 
• Microsoft 365 A3/A5/ Student Use Benefits 
• Microsoft 365 F1/F3 
• Microsoft 365 Business 
• Windows 10 Enterprise E3/E5 
• Windows 10 Education A3/A5 
• Windows 10 VDA per user 
• Remote Desktop Services (RDS) Client Access License (CAL) 
• Remote Desktop Services (RDS) Subscriber Access License (SAL) 
• Azure Virtual Desktop per-user access license 

In the Azure Marketplace, Windows 10 and 11 multi-session SKUs come with the FSLogix agent pre-installed by default. This eliminates the need to go through the process of installing or updating FSLogix on virtual machines, allowing you to immediately benefit from its excellent features. 

FSLogix is now synchronized with Windows and follows the Microsoft “Patch Tuesday” release schedule. That means whenever a new version of FSLogix becomes available, it will be released on the same day as Windows updates. As a result, the Azure Marketplace images for Windows multi-session will consistently feature the most up-to-date version of FSLogix. 

Of course, it is still an option to use FSLogix App Masking in other Windows 10, 11 or Server SKU(s). FSLogix must be installed manually on the session host virtual machines (VMs) or as part of an automated deployment or golden image. The latest version of FSLogix can be downloaded via the following link https://aka.ms/fslogix_download. 

An even better option would be the Liquit agent installation as part of Infrastructure-as-Code (IaC), which involves automating the provisioning and configuration of the Liquit agent on infrastructure resources. Liquit can then ensure application sets are installed with all necessary settings and the latest available version with one Liquit deployment. There are many ways Liquit can help your organization and bring advantages to your image processing strategy, which I described in this previous blogs. 

Enhancing PDF Processing with FSLogix App Masking and Microsoft Integration

By default, Foxit PDF Reader will be made available to all users for opening PDF files. But some select groups will prefer a different application such as Adobe Acrobat Reader DC. 

The first step is to create a rule using the FSLogix Apps Rule Editor installed on a Test VM. If a user is a member of a Microsoft Entra Security Group, these rule sets will make use of environment variables that we can create with Liquit Workspace. 

The second step involves uploading the rule sets to Liquit Workspace and using them in a Liquit Deployment to make them available on Azure Virtual Desktop session hosts.

The third step is to create two Liquit packages for the FSLogix App Masking of Adobe Acrobat Reader and Foxit PDF Reader. This will be executed at Liquit Logon with a Filter on the Action set that will check if environment variables exist. There is also a filter on the package that will check if the user is a Microsoft Entra security group member. 

Adobe Acrobat Reader DC 

Actions:

Filter on Action:

Filters:

Foxit PDF Reader 

Actions:

Filter on Action:

Filters:

Lastly, we make the right PDF Viewer available in the Liquit Workspace and settings for the File Association (User Based) for .PDF based on the membership of the Security group. The File Association will be set at Liquit Logon. 

Adobe Acrobat Reader DC 

Foxit PDF Reader 

How Does the Result Look? 

Below is a short demo to show how it looks when different users login on a multi-session host. 

Step-by-Step Guide: Configuring FSLogix App Masking with Microsoft Entra

With this solution in place, the IT department can overcome the FSLogix limitation of not supporting Microsoft Entra groups when session hosts are joined to Microsoft Entra only. This approach is what we call Elevating FSLogix App Masking in AVD with a Liquit touch.

To learn more about how you Elevate FSlogix App Masking in AVD with Liquit, reach out to one of our official Liquit partners here. 

The post Elevating FSlogix App Masking in AVD with Liquit appeared first on Recast Software.

Liquit enables organizations to dynamically manage and deliver applications based on context, tailored to specific users or devices.

Understanding Mission-Critical Applications

A “mission-critical” application is essential to an organization’s core functions and operations. Significant downtime can lead to financial losses and disrupt business processes. Examples include ERP, CRM, financial management software, and other applications vital to the organization’s objectives and daily operations.

Hiding Mission-Critical Applications for Specific Hours

While Liquit Workspace offers powerful contextual capabilities, the requested functionality isn’t available out-of-the-box. However, Liquit’s flexibility and programming power allow IT admins to implement it in most cases.

Organizations often deal with tech-savvy users, some with local admin rights, who might try to bypass restrictions by adjusting the time and date or locating the application in Windows Explorer. Addressing these potential issues is crucial.

Addressing Application Delivery Challenges in Liquit Workspace

There are various reasons to limit access to certain applications during specific times. Our goal is to:

• Ensure the “mission-critical” application is only visible and accessible during business hours and masked or uninstalled during non-business hours. For example, access is governed by the Amsterdam time zone.
• Address potential issues with tech-savvy users attempting to bypass restrictions.

To achieve this, we avoid using the local device’s date and time, as these can be adjusted by users with admin rights. Instead, we use an API for IP geolocation and the Europe/Amsterdam time zone, along with a PowerShell script, ensuring accurate timing regardless of the user’s location. The PowerShell script outputs the day of the week and time, which are used by the condition sets “Get Day of the Week” and “Get Time” to determine the appropriate action.

To achieve the above, we can think of two scenarios that will be supported by videos in this blog. Both scenarios will use ERP software from Exact Global Next as a “mission-critical” application example.  

Scenario 1: Solving Application Delivery Challenges During Business Hours

The user clicks on the application during business hours and receives an “Outside Business Hours” notification. The application is then masked or uninstalled, preventing it from being launched from the Start menu or executed via Windows Explorer.

Scenario 2: Overcoming Time-Based Application Delivery Challenges

The application is visible in Liquit Workspace during business hours but hidden outside of business hours. Again, the application is masked or uninstalled to prevent access.

Conclusion: Resolving Application Delivery Challenges with Liquit Workspace

This is just one of many challenges that can arise in a dynamic, distributed organization or hybrid remote workforce. Liquit Workspace offers context aware solutions that are easily implemented and automatically executed.

For more information about contexts and their usage, visit Liquit Workspace identities and context documentation.

The post Overcoming Application Delivery Challenges with Liquit appeared first on Recast Software.

It’s clear to everyone that digital transformation demands that organizations create a more adaptive digital workplace to support the ability of employees to work from anywhere, on any device, at any time. Since application management and delivery is the foundation of that workspace, they must find ways to overcome barriers by embracing the most versatile technologies.

Unlocking Image Processing Automation with Virtualization Infrastructure

Many organizations continue to use virtualization infrastructure to deliver applications and complete desktop environments to their end users. One of the primary reasons for application and desktop virtualization is the need for legacy application support, allowing organizations to run legacy applications that may be incompatible with newer operating systems. Liquit offers ease of access and unified management in environments where combined VDI and SBC are common.

Bridging the Integration Gap with Liquit Connectors

Liquit enables organizations to continue using virtualization infrastructure, regardless of the platform, by leveraging automation through Liquit Connectors. Connectors are components within Liquit that allow integration with various platforms and services, extending the capabilities of legacy tools and providing users with seamless access to external resources. For example, many enterprises rely on solutions like Citrix Storefront to aggregate and present on-premises and hybrid virtual app and desktop resources. Liquit Connectors simplify the process, allowing IT teams to easily connect and deploy without complexity or adverse user impact.

Simplifying Image Processing with Unified Deployment through Liquit

Liquit goes a step further by empowering you to create a single deployment for virtualization infrastructure and physical laptops, enabling the installation of multiple applications with customized settings. This includes tasks like Registry tweaks, drivers, and optimization tools/scripts for Citrix, VMware, or AVD (Azure Virtual Desktop) environments. Liquit seamlessly handles application deployment and management, ensuring all applications stay updated with the latest patches and security fixes.

Effortless Patch Management

While patching has always been a difficult management challenge for many organizations, Liquit Release & Patch Management makes it easy by automating patch deployment. This ensures that all applications stay current with the latest patches and security fixes to minimize vulnerabilities and security breaches caused by outdated software, which ultimately leads to improved compliance.

Another excellent feature is our Development, Testing, Acceptance, and Production (DTAP) model, which is part of Liquit Release & Patch Management, along with the Liquit Setup Store. Liquit Release & Patch Management provides significant agility by linking Citrix virtual apps and desktops to both test and production stages.

So, what benefits does Liquit implementation deliver as part of your imaging process and strategy?

• Automated patch management: Liquit’s Release & Patch Management ensures that all applications stay up to date with the latest patches and security fixes. By automating patch deployment, Liquit minimizes the risk of vulnerabilities, prevents security breaches caused by outdated software, and improves compliance.
• Major time savings and efficiency Improvement: Liquit automation reduces manual tasks for faster implementations by eliminating repetitive tasks and reducing human errors to deliver, higher productivity and a shorter time-to-market.
• Consistency and reliability: Automated deployments ensure consistency across environments to minimize configuration discrepancies and implementation issues caused by human error while providing a reliable and standardized imaging process.
• Scalability: Automation allows deployments to scale and meet increased demand or workload requirements. Liquit enables software deployment on multiple platforms simultaneously, whether it’s on-premises or in the cloud.
• Resource optimization: By reducing manual intervention, automation frees up time and resources. Employees can focus on other essential tasks, such as improving performance and enhancing the user experience.

Revolutionize Your Image Processing Strategy with Automation

Liquit is key to revolutionizing your organization’s imaging process and strategy by unlocking efficiency, scalability, reliability, and resource optimization in application and desktop management. To learn more about how you can say goodbye to manual tasks and embrace a seamless, automated future with Liquit, reach out to one of our official Liquit partners here.

The post Unleash Image Processing Automation with Liquit appeared first on Recast Software.