Join Sean Colins for an in-depth discussion in this video Exploring the monolithic and modular imaging methodologies, part of Imaging and Deploying Macintosh Computers.
As someone who's responsible for configuring the perfect computer and then deploying it out to all of the different computing machines that you are responsible for, you'll be concerned with the various methods that you could use for creating those master images and deploying them out to all of those computers. So, let's discuss some of the basic methodologies that are available to you. You'll hear me talk about monolithic imaging and modular imaging. So, let's get started with that by defining our terms.
First, let's deal with monolithic. So, as it implies, monolithic means that we're going to create one big thing that contains many different parts. Now what do we mean by that? Well, whenever you build a master computer, what you're doing is you're booting up your Macintosh. You are making sure that it has the proper version of the operating system on it. You're running whatever software updates are available. Maybe you'll install some custom print drivers that you need for your environment.
Maybe you'll add some administrative and maybe some local user accounts, change some settings here, some settings there, install some applications. Once you have everything the way that you want it, you then take all of those bits and pieces that you've added on to that computer and you'll make one big image of that computer. And then you'll store that image to be redeployed out to other computers. That's the monolithic model. The next model is the modular model.
In the modular model, we take all of those individual parts and we keep them separate in workflow elements until the last possible moment before deployment. So, for example, you've got your base operating system. You have the applications. You have the printer drivers. You have maybe some files that need to be installed. You could even have settings pre-saved in plist format that you can move into position later on. All of those elements are put into place via workflow elements.
And then when the deployment happens, the operating system goes down and then as part of the modules after that process, the installers all install their applications onto each individual computer. Files are moved into place all in an automated fashion. So, that's the difference between modular and what we talked about previously with our monolithic. So, how do we construct this? Well, a monolithic disk image can be constructed with many different tools.
We have a few that we're going to be covering in this title. We'll be covering DeployStudio, Disk Utility, and we'll be covering System Image Utility. Now we'll be doing that even though there are other tools out there. There are companies like JAMF and FileWave and others that make very, very good tools for creation of disk images and packages to do either monolithic or modular distributions. However, DeployStudio and Disk Utility and System Image Utility will all be available either free as a download or will already be on the Macintosh that you're using to begin with.
DeployStudio is a free download, Disk Utility and System Image Utility are on every Mac. So, we'll be covering those. For modular construction, we're going to talk about DeployStudio and System Image Utility. We won't be talking about Disk Utility with our modular construction methods because Disk Utility doesn't support that. So, let's talk about building a monolithic image with DeployStudio. This process starts with building a master system. Then you move on to creating an image from a master, and you'll get into the DeployStudio software in order to do that.
But in building that master system, you'll do everything I described before. You'll already have an operating system installed. You will have installed your applications, your printer drivers, you will be setting up your printers, setting up any local user accounts you need, providing all of the settings, and then making that master. DeployStudio takes a little while to create the image. And then when that image creation process is completed, you'll want to then boot into DeployStudio over the network or on a local hard drive.
We'll talk about how to do that later. And test your restore of that master to verify that the result is what you were looking for. Another option for monolithic distribution or master creation is Disk Utility. In much the same way that you would build a master for a DeployStudio deployment, you'll build that master for Disk Utility. You'll install the operating system, applications, printer drivers, settings, etc. But then, when you're finished, you'll want to delete any computer-specific files, you'll remove ByHost preferences.
We'll talk about what those are later on. And you'll be certain to remove the local Kerberos Key Distribution Center, or the KDC. This is important because these files are either specific to the computer on which you built the master or they need to be individualized after deployment. So it's very important to do something with these files on this system before you use Disk Utility to create the image from the master and that process is very manual.
Once you're certain you've removed the local KDC and all of the specific computer files that are needed, you will then use Disk Utility to create your master image. And when the master image is created, you'll then select that master image and use Disk Utility to do something called scanning it for ASR. ASR stands for Apple Software Restore. And once you've completed that process, the resulting image can be used to deploy back to computers.
Now, that image will be available to use in Disk Utility and we'll talk about methods of deployment later on. But this would be the process you'd go through to create this monolithic image using Disk Utility. Once you've completed scanning your image for restore with ASR using Disk Utility, you will then use that Disk Utility program to test restoring the resulting image to another Mac just to be sure that whenever it's restored, the system that you restore it to will boot and it functions as you would expect. Next, let’s talk about System Image Utility for our monolithic model.
With System Image Utility, you can build a master system just as before, adding your own applications, etc. As we’ve already described. In the case of System Image Utility, you can choose to delete some computer-specific files. And depending on whether or not you use an automated or manual workflow process, you may or may not need to delete those computer-specific files like KDC or any ByHost preferences. You then use System Image Utility, which is again, located on every Mac in System> Library > Core Services, to create that image from your master.
Once you've got your master, it will be in the form of an NBI set. You're going to need to build an OS X server with the necessary services turned on in order to host that NBI set properly, and to be used for a network deployment. You then need to move the NBI set into place so that it can be visible from the NetRestore system. And then you're going to use NetInstall to test restore the result to a system over the network. All right, so that finishes up our monolithic models.
Let's move on to our first modular model, and that is with DeployStudio. Now, DeployStudio allows you to select a volume that contains the base operating system as a starting point for a workflow. Then, you would use DeployStudio to capture that base OS image. And you would use the workflow builder within DeployStudio to add on applications, files, users. You could specify settings and then whenever you're finished, you will boot into the finished deployment workflow.
Run the workflow and then when DeployStudio images your remote system during its testing, it will lay down the base operating system and then it will lay down the application, the preferences, the user accounts, and all of the other things that you told it to lay down. As you can see, this modular model give you some benefits over the monolithic. If you build one large monolithic image, you are building one big thing. And then if you want to make a very, very small change, you need to go back to your master, or redeploy your master to a computer, make the small change and then make a whole new big large image.
Now, this is very simple, but it can be very time-consuming. Whereas with a modular model, you can make one small change to, say, a version of an application that's installed as part of the workflow or maybe there's a plist file that contains a preference you want to change. All you would need to do is replace that one element in the workflow and then the very next system that you image with your modular workflow would result in the changes that you had made. Another way to do this is with System Image Utility, but System Image Utility handles modularity in a slightly different way.
It does allow you to use an installer or hard drive to indicate a master base OS, and then it does have an automator-based builder to add on apps, files, user accounts, or settings. But with System Image Utility, it then builds the deployment into an NBI set that results in a monolithic image that needs to be deployed as one large thing. And then fixing it or changing it allows you to go back into your saved workflow, but then it has to go and build the entire large NBI set over again, which is different from the way that the modularity works with DeployStudio.
So you can see there is a difference even here within the two different modular models. Next, we'll talk about different imaging types.
- Exploring the monolithic and modular imaging methodologies
- Working with Fusion Drives and Recovery partitions
- Ensuring physical security and installing a firmware password
- Choosing source hardware
- Installing apps
- Building a complete monolithic master for imaging
- Deploying apps and accounts in a modular master system
- Building a base master
- Performing hard-drive-to-hard-drive imaging
- Exploring VLANs
- Performing network-to-network imaging
- Deploying using NetInstall or DeployStudio across a network