M365Con 2027 – free online conference · 11–22 Jan 2027 · 120 sessions m365con.net

2026-11-21

Image Management for Virtual Desktops – Simply Explained

Follow the showNew episodes on Microsoft 365, Copilot and more, free in your podcast app.Apple PodcastsSpotify
Cover: Image Management for Virtual Desktops – Simply Explained
Setting up virtual desktops by hand works until you have two hundred of them. Image management fixes that: you build one master copy, deploy from it and update it in a controlled way. In this episode of Simply Explained you will learn: - What a golden image is and why one master copy beats building…

Show notes

Setting up virtual desktops by hand works until you have two hundred of them. Image management fixes that: you build one master copy, deploy from it and update it in a controlled way. In this episode of Simply Explained you will learn:

  • What a golden image is and why one master copy beats building every desktop by hand
  • Why you cannot simply clone a running desktop and what generalizing (sysprep) does
  • How Azure Compute Gallery stores and versions your images
  • Why user profiles live outside the image, and how FSLogix keeps them safe during a re-image
  • How an update reaches running desktops in waves with drain mode
  • Where image management breaks down and the mistakes teams make most often

Simply Explained by M365.FM breaks down Microsoft 365, Azure and modern IT topics in clear, jargon-free language. Hosted by Mirko Peters. Become a supporter of this podcast: https://www.spreaker.com/podcast/m365-fm-microsoft-365-azure-cloud-power-platform-ai--6704921/support. This episode includes AI-generated content.

Host: Mirko Peters

Guests

Guests in this episode:

Transcript

Transcript (TXT)

Read the full transcript

Speaker 1: Setting up a virtual desktop by hand works fine until you have 200 of them. At that point, every change becomes a project and every machine slowly drifts away from the last one you touched. Image management is the practice that fixes this. You build one master copy of the desktop, capture it and deploy from it. By the end, the pieces will line up and you will also know the spots where this approach falls apart. Think about how you build a virtual desktop today. You start with an operating system. Then you add the apps your team needs, then you set the browser homepage, the security agent, the printer, and the small preferences that make the desktop usable. It's a long checklist, and it's the same checklist every single time. Now imagine doing that for 200 people, the checklist doesn't get shorter, and the room for a mistake grows with every desktop you build. One desktop gets the old version of an app, another gets the wrong security setting, and a third never gets finished because something else came up. A golden image is how you stop repeating that work. In plain terms, it's one master copy of a desktop that holds the operating system, the apps, and the settings you want on every machine. You build that copy carefully one time, and then you use it as the starting point for every desktop you deploy. Microsoft describes it almost exactly that way. A golden image is a custom image that contains all the apps and configuration settings you want to apply to your deployment. The name sounds like jargon, and it's really just shorthand for the one good copy you keep around. Here's a concrete example. Say your support team needs three specific applications, a browser pointed at a couple of internal sites, and a security agent that reports back to your management console. You put all of that into the image once. Every desktop built from it arrives with those pieces already in place, so nobody has to remember them one at a time. The payoff shows up in two places. The first is speed, because deploying a desktop becomes a copy operation instead of an afternoon of clicking. The second is consistency, because every desktop starts from the same known good state instead of from whatever the last person happened to remember. That consistency is the real prize. When two desktops are built differently, you get problems that show up on one machine and nowhere else. You then spend hours chasing a difference that shouldn't exist. and a golden image removes most of that guesswork before it starts. So the idea is simple. It comes down to one master copy built with care and reused everywhere. The interesting part is what you have to do to that copy before it can be reused safely, and that's where the next step comes in. At this point, the shortcut looks obvious. You already have a desktop that works, so why not clone it and hand out copies? The answer is that a running desktop carries a lot of information that should only ever belong to one machine, Every Windows installation has its own identity. It has a computer name, a set of accounts, and a pile of machine-specific settings that are fine on one desktop and confusing on the second one. If you clone a desktop without cleaning that up, you end up with machines that collide with each other. Others get stuck on the first-run screen instead of starting normally. The cleaning step is called generalizing. On Windows, the tool that does it is sysprep. What it does is remove the machine-specific user information so the image can be used to create many machines. On Linux, the equivalent step is deprovisioning, which the Azure Linux agent handles. This step is where most of the sharp edges live, so it's worth knowing the rules before you touch it. Encryption has to be turned off first because sysprep needs the drives fully decrypted. The DVD drive has to be enabled or the new machine gets stuck at the first run experience. Antivirus can interfere with sysprep, so it's usually disabled before you run it. And the unified write filter, a feature that can be handy elsewhere, isn't supported on these desktops and shouldn't be enabled in the image. The most important rule is that generalizing is a one-way door. Once a machine has been generalized, it can't be started again and the process can't be undone. That single fact explains the recommended workflow. You don't generalize your good machine. You clone it. generalize the clone, capture the image from the clone, and then throw the clone away. The original stays intact, ready to be updated for the next round. There's one more trap worth naming because it catches people who are being careful. Don't join the golden image machine to a host pool, which is the group of desktops users connect to with the Azure Virtual Desktop agent. It feels harmless and it isn't because the registration token that ties a machine to a pool expires. machines you build later from that image then fail to join, and the failure is confusing because the image itself looks fine. So the shortcut is real, but it comes with a preparation step that has to be done correctly. Once the image is prepared, the next question is where you keep it and how you tell one version from another. In Azure, the place you keep your images is called the Azure Compute Gallery, and you may also see it called a Shared Image Gallery, It sounds like one thing, but it's really four pieces working together, and the names make more sense once you line them up. The first piece is the image source, which is whatever you build the image from, such as a virtual machine or a managed disk. The second is the gallery itself, which is the shelf where everything lives. The third is the image definition, which is the label on the box. It records what the image is for, such as whether it's Windows or Linux and whether it has been generalized. The fourth is the image version, and that's the actual box you deploy from. The gallery works like a library shelf, the image definition is the label that says what belongs in this spot, and the image version is the specific edition you pull down. You don't deploy from the definition you deploy from a version. Versions use a simple numbering scheme with three parts and you read them from left to right. A version like 2.1.0 and a version like 2.1.3 belong to the same image definition. The second one is newer because the last number is higher. When you ask for the latest version, Azure picks the highest first number, then the highest second number, then the highest third number. That numbering is more useful than it sounds. It means you can keep an older version around as a fallback and publish a new one. You can then switch between them on purpose, instead of hoping you remember which copy was the good one. Microsoft recommends the gallery for production environments because of two features, replication and versioning. Replication means copies of the image can live in more than one region, so desktops in another location aren't pulling across the world. Versioning is the numbered scheme we just walked through. If you have a very simple setup, a single standalone managed image can be enough, but you give up those two features. The cost picture is refreshingly small. There's no charge for the gallery itself, you pay for the storage that holds the image versions, and for the network traffic when you replicate them to other regions. You can also share images from a gallery in a few ways, through role-based access, a direct shared gallery, or a community gallery, depending on who needs them. One last detail is worth remembering. If you delete an image from the gallery, desktops already built from it keep running because they have their own disks. Anything that scales out from that image reference though will fail, so clean up with that in mind. One idea makes everything else click. The image is the machine and the user's data is not on the machine. That sounds strange if you're used to a laptop where the operating system and your files live together on one disk. Virtual desktops can work differently. In a pooled setup, a person might land on a different desktop every time they sign in, so their files and settings can't live on any single machine. If they did, the person would get a blank desktop the moment they landed somewhere new. The way this is usually solved is with a profile container, and the common tool for it is FSLogix. Instead of leaving the profile on the machine, FSLogix stores the whole user profile in a single container, and that container attaches at sign-in. To the user, it looks and behaves exactly like a normal profile. their desktop background, their Outlook cache and their OneDrive folder all follow them from one desktop to the next. One clean mental model is worth keeping. The image is the machine and the profile container is the person. When you replace the machine, you aren't touching the person. That's why a re-image can swap the entire operating system without wiping the user's world. There's an honest dependency here. In a non-persistent virtual desktop setup, OneDrive isn't supported without something like FSLogix doing this work, so the two ideas aren't separate projects. Image management and profile management are two halves of the same plan. There's also a boundary. This pairing suits pooled, non-persistent desktops where machines are meant to be interchangeable. It isn't the recommended pattern for personal, persistent desktops that need per-user installations and settings. to stay put on one machine. Those desktops want to keep their own state, and re-imaging them on a schedule is the wrong move. Now that the machine and the person are separated, the machine becomes something you can update safely. That brings us to the part most teams get wrong when they first try this. You have a new image, and you want it on the desktops people are using. The naive way is to replace every desktop at once, and that's exactly how you take down an entire team on a Monday morning. The good news is that the real process is built to avoid that. The core operation is called re-imaging, and in simple terms it replaces the operating system disk of the desktops in the pool with the new image. In Nerdio Manager, for example, you update the desktop image, and then you run a re-image task against the host pools that use it. The task can run right away, or you can schedule it to run overnight. The part that protects your users is how the work is spread out. Desktops are processed in groups rather than all at once and there's a documented limit of 100 machines per group. After the first group finishes, the remaining desktops can be set to drain mode. Drain mode is worth explaining. because the name doesn't give it away. When a desktop is in drain mode, no new users are sent to it. Anyone already signed in keeps working, but the next person who connects goes somewhere else. In practice, that means people are only ever routed to a desktop that has already been updated, so the change happens quietly in the background. That design choice is the difference between an update your users never notice and an update they remember, for the wrong reasons. You can also warn people before it happens. A message can be sent ahead of the change with a delay, so a user gets a heads up instead of a surprise. If several host pools share the same image, you repeat the update for each pool. That sounds tedious, and it's exactly the kind of repeated step that a management layer is meant to handle. It saves you from clicking through the same dialogue for every pool by hand. There's one more safety feature worth naming because it saves a lot of pain. Before an image is published, you can validate it, which means applying it to a machine and checking that the machine actually boots. It's a small step that catches a broken image before it reaches a single user. The order matters here and it's easy to get backwards. Finish the image update first. Only then re-image the desktops. If you re-image before the image is ready, you've just rolled out the old version with extra steps. One update is a task. Doing this every month is a process, and the process is where the time savings actually come from. The rhythm is simple to describe. Patches and app changes land on the image first. Then the image rolls out to the pools. You never patch the live desktops directly because that's how they drift away from the image. The image then becomes a stale backup that's useless when you need it most. Nerdia documents this as a four-step flow, and it's a useful shape even if you use different tools. First, you assign the update scripts to the account. Second, you run those scripts on the desktop image. Third, you set up notifications so you find out when something fails. Fourth, you schedule the re-image so the new image actually reaches the desktops. The recommended cadence is monthly, and the documentation suggests leaving a buffer between the two halves. Its example is to patch the image at 4 in the morning and re-image the pools at 10. That gives the patching job time to finish before anything is rolled out. There's a step in between that's easy to skip and expensive to skip. Before a new image goes live, you can stage it, which means testing the new version while the pools keep using the old one. Once you're satisfied, you mark it active and let it roll out. Staging is the seatbelt of this whole process because it separates the moment you build something from the moment it goes live. Automation is what turns this from a chore into a habit. If the same steps are done by hand every month, the details get skipped, and the skipping is what causes drift. A scheduled job does the same thing the same way every time, which is the whole point. Keeping a record matters too. A change log for your images tells you who changed what and when. So when two versions look identical, you can still tell them apart. That record is what saves you during an outage when you need to know which version you can trust. For providers managing many customers, this can scale further. Images can be staged centrally and shared across accounts, so you build the good copy once and use it everywhere it applies. That's where a management layer earns its place, because doing this by hand for dozens of accounts is a full-time job on its own. Everything so far has been the case for doing this. Now, here's the honest part, because this approach fails in a few predictable ways. The first mistake is patching live desktops by hand and leaving the image alone. It feels faster in the moment, and it slowly ruins the thing you built. If your desktops have three months of changes and your image is still in its original state, the image can no longer rebuild those desktops. When a machine fails and you reach for the image, you get a desktop from three months ago. The second mistake is installing apps directly on a dynamic desktop. In a pool setup, those machines are designed to be swapped freely, so anything you install by hand is lost or reverted the next time the machine is re-imaged. If an app belongs on the desktop, it belongs in the image. The third mistake is treating this as a one-time project. You build the golden image, deploy it, and then let it age while the desktops move on. The image isn't set and forget it needs the same cadence as the desktops it serves. The fourth mistake is assuming this fits every workload and it doesn't. For personal desktops that keep per-user installs and settings on the machine, the recommended pattern is to let each one hold its own state. Reimaging those on a schedule fights the thing the user actually needs. Then there's the fragility of the preparation step itself. Local accounts left on the machine can cause the generalized step to fail, and encryption, antivirus, and a disabled DVD drive can each break it in their own way. And remember the one-way door. Once a machine is generalized, it can't be started again, which is why the safe habit is to generalize a clone and keep the original untouched. The cost of a bad rollout is worth stating plainly. Every image that goes wrong can take desktops out of service, and that's why the waves, the drain mode, and the validations that exist aren't decoration. They're the difference between a routine update and a bad morning. So here's the honest summary. Image management removes a mountain of repeated work, and in exchange, it asks you to run a process with care. If you take one thing from this, let it be the split. One master image holds the operating system and the apps, and the profile container holds the person. Everything else follows from keeping those two ideas separate. The pieces fit together like this. You build a golden image with the apps and settings you want. You prepare it by generalizing a clone so the machine-specific details are gone and it can be reused. You keep it in a gallery as a numbered version so you can tell versions apart and roll back if you need to. You roll it out by re-imaging desktops in waves using drain mode so users are never dropped. and you run the whole cycle on a repeating timetable with staging and validation as your safety nets, the value isn't in the image itself, the value is in the repeatable process around it, and that's what makes updates boring, which is exactly what you want. Here's my question for you. How does your team roll out an app or a patch to your virtual desktops today, and does that process hold up when it has to run 100 times? If this made the topic feel less intimidating, Subscribe to M365FM to master the tools and the mindset shaping the future of work.