Synergy also enabled us to talk to a slew of consumers at various phases of the Application Layering journeys who'd an extensive variety of ideas, needs, and challenges. Understandably, between these interactions and also the many purchasers deploying Application Layering we talk to included in our day jobs, we heard some common styles. So for individuals individuals a new comer to Application Layering, I’m going to express the very best four mistakes I see customers making in early stages within their Citrix Application Layering journeys and a few tips about how to prevent them.
1 - Misaligned PoC versus. Production Expectations
Why is Citrix Application Layering not the same as the many other application layering technologies available on the market is the fact that things are a layer, such as the OS itself. This enables us not only to lessen the potential quantity of images you have to manage but additionally to help make the images that you simply do need better to manage.
To facilitate this, the Enterprise Layer Manager (ELM) must create full images from teams of layers and publish these images for your various platforms and provisioning systems (though we’ve made significant performance optimizations to the way we do packaging during the last 18 several weeks). Lengthy story short, packaging and publishing is IOPS- and bandwidth-intensive.
When PoC’ing Application Layering, if you are not using production-grade hardware or taking other shortcuts you would not being produced for example packaging/publishing within the WAN, packaging and publishing will probably have a good bit more than they'll in your snappy production hardware with a seem architecture for packaging and publishing inside your various data centers and clouds. Make certain that whenever you’re evaluating Application Layering, that you simply contextualize packaging and publishing occasions using the hardware platform you’re running the PoC on and also the network links you’re traversing versus what you’d really use within production, which in my opinion is frequently considerably faster.
2 - Didn’t Have a Clean Copy from the OS Layer
As you may know, application and platform layers are associated with OS Layers, not OSes. When designing layered images, you are able to only select application and platform layers which were produced while using OS layer (or versions from the OS layer) these were produced with. The important thing implication of the is the fact that when you have to rebuild your OS layer on your own, you’d should also rebuild your full stack of corresponding application/plat layers.
You are able to mind this issue off by doing a couple of things from the beginning:
- Before importing your OS Layer, install Home windows in the official ISO from Microsoft, run Home windows Update, install the hypervisor tools from the virtualization platform you’re using for packaging, and install and run the OS Machine Tools around the image. That’s all! No updates, not one other software, no optimizations. (One that’s bitten a couple of of my customers is removing Store apps, a suggested optimization should you not need them. However this has demonstrated hard to add back later whenever a requirement for their services has come to light.) These may be done like a latest version from the OS layer. This provides the cleanest possible imported OS layer like a beginning point.
- Since you’ve produced this perfectly clean OS Layer, which you'll subsequently modify through as numerous versions while you please, never delete the initial imported version. Returning to the constraint described above, this could permit you to “rebuild” your OS layer basically on your own, without getting to import a brand new OS layer and all sorts of fun connected with this. As an additional benefit, this is often handy to need to help eliminate optimizations/updates/other software within the OS layer as variables when troubleshooting a problem by having an application layer.
If you are already far lower the road together with your Application Layering deployment and didn’t do that (or something like that for this), take it easy. The scenarios that will need a complete OS layer rebuild are uncommon. Just make certain you follow this guidance with any future OS layers you develop.
3 - Didn’t Adjust Operational Paradigms to Application Layering Way
Managing applications and pictures with Citrix Application Layering is totally different from what you’re accustomed to. The ELM is what’s really creating your images, and no machines you utilize to include or update applications are domain-became a member of or perhaps make use of a consistent name, simply to name a couple of. Consequently, I have seen lots of customers spend considerable time fighting two battles particularly:
- Trying to consume a current “corporate standard” operating-system build because the OS layer: For Exhibit 1 against importing a “corporate standard” build as the OS layer, begin to see the previous mistake concerning the OS layer. I are often requested, “Well, what bad things might happen basically include X, Y, and Z apps within my OS layer that you simply don’t recommend putting to your OS layer?” That’s a hopeless question to reply to generally. The solution might be “nothing” if you are lucky, to “a complete rebuild of layers for your OS” if you are unlucky. The greater approach would be to do things the Application Layering way: help make your OS layer as minimal as you possibly can and do anything else to supplement layers. You are able to attain the same finish result so far as software, security lockdowns, etc. are worried, but you’re potentially saving yourself lots of headaches by not attempting to retrofit existing processes in to the Application Layering operational model.
- Attempting to leverage existing software deployment tools (SCCM, BigFix, etc.) like a main issue with the layer creating increase process: With regards to software deployment products and Citrix Application Layering, there is a whole litany of fabric I possibly could discuss about this subject. However in general, the way in which packaging machines are spun up makes targeting difficult (not domain-became a member of, name from the machine will be different, IP is placed via DHCP). Time that you’d spend taking additional steps to operate for this (and troubleshooting steps should you unintentionally put things right into a layer that should not be there) frequently completely offsets the advantage of getting used the deployment tool to set upOrrevise the application. My “broad strokes” advice here is you obtain the best value for your money if you use the packages you produced for that tools, although not the various tools themselves, for handling the deployments.
I am not saying it's not within the arena of possible ways to do either of individuals things, but in my opinion, I haven’t seen success within the lengthy term with attempting to retrofit either of individuals products in to the Application Layering world. Attempting to do this can also add more complexity for your approach than you might have expected.
Lengthy story short: when you are mired in discussions on how to integrate Citrix Application Layering into legacy processes and you’re concerned that doing this moves you from our suggested practices or it simply doesn’t appear to create sense with the way in which Application Layering works, your intuition is most likely right. Move back, consider the main issue, and push to obtain buy-set for the “App Layering way” to do things, which doesn’t align with lots of existing management paradigms which were made with another technology stack and hang of challenges in your mind.
4 - Too Dependent on Elastic Layering in Layering Strategy
Prior to getting too much into this, allow me to be obvious: Elastic Layering is really a critical a part of Citrix Application Layering technology. The opportunity to map applications to users is crucial when designing a non-persistent workspace solution for any broad group of use cases. I am not downplaying the significance of Elastic Layering, however i will have some practical suggestions about how to generate a layering strategy that best meets your needs.
Basically were built with a nickel for each time someone’s articulated taking on “one gold image per OS” cure all … you understand. Elastic Layering, certainly, will help you enable you to get nearer to that goal. However, unless of course you’re using Citrix Virtual Apps and Desktops for any small group of perfectly-defined user populations, despite Elastic Layering within the picture, this is extremely hard to achieve in functionality.
There's two primary reasons for this. First, not every apps works with Elastic Layering (or any application layering technology that mounts applications at logon). Inevitably, a minumum of one application outdoors of the core apps needs to become incorporated inside a layered Image. Second, even though you could deliver each and every non-core application elastically, you most likely wouldn’t wish to. While we’ve made logon performance better with Elastic Layering through features like late load, it’s one more filter driver within the stack and the other group of activities that should happen at login, which inevitably will add time for you to logins. That’s a trade-from you can’t make with certain use cases.
To sum it up, do not begin your trip looking to get one image per OS by utilizing Elastic Layering for each application. It's not realistic - for just about any application layering technology - but that’s OK! As described above, that’s what’s so excellent about layered images: You do not incur exactly the same management overhead adding additional images that you'd should you weren’t using Citrix Application Layering. (I talk a little more relating to this here and here.)
Wrapping Some Misconception (TLDR)
When beginning your Application Layering journey, keep these four things in your mind to prevent common errors:
- Don’t judge packaging and publishing performance in your PoC atmosphere running on old, slow hardware. Your production atmosphere ought to be better outfitted to handle IOPS and bandwidth required for fast packaging and publishing, and you'll finish track of a multi-ELM architecture to help keep the majority of that activity close to the information center.
- Make an very clean OS build for import (no optimizations, no personalization, not one other apps), and hang up about it forever. This can help you save from some substantial rebuild work should you encounter difficulties with your OS layer lower the street.
- Citrix Application Layering requires completely different operational methodology than you enables you to for updating and testing apps and pictures. Embrace the “App Layering way” and adjust your operational methodology to best squeeze into the functionality of Application Layering instead of attempting to fit a square peg right into a round hole.
- Elastic Layering is excellent but comes with an connected group of design factors. Make certain your whole strategy doesn’t hinge on having the ability to elastically layer nearly all your apps, out on another measure your ability to succeed solely on image-count reduction.