Invoke CM_Build over the Web

Updated 10/15/2017 – Added -Override example

118057481

First off: WTF is CM_BUILD?

CM_BUILD is a PowerShell script that configures a “vanilla” Windows Server machine into having Configuration Manager Current Branch installed.  This includes ADK, MDT, Server Roles and Features (WSUS, BITS, etc.), SQL Server, ConfigMgr itself, and a few goodies like Right-Click Tools, ConfigMgr Toolkit.  The GitHub repo has a cute readme markdown page filled with overcaffeinated gibberish on how to use it.  CM_SiteConfig is the “part 2” to cm_build, which configures ConfigMgr into a semi-functional site.

Short answer: https://github.com/Skatterbrainz/CM_Build

Okay, why CM_BUILD?

I don’t know.  Why do we do anything?  For the thrills? I could have taken up robbing banks, raising a crocodile farm, or breaking world records of swilling down cans of Four Loco while working on electrical equipment.  But I chose the boring life.  And while I’m bored, I hate clicking buttons repeatedly, so …

I got inspired by Johan and Mikael’s ConfigMgr Hydration Kits and Deployment Fundamentals Vol. 6 book examples, and Niall’s noob scripts, (I know it’s not actually called that, but it sounds cool to say “Niall’s noob scripts“), and after 45 cups of terrible coffee I said “I can shove all that into an XML file and call my JSON friends up and laugh hysterically at them, saying things like ‘You and your snotty little JSON drivel!  Always mocking poor, starving little XML.  Well, I’ll have you know I can still write XML, and probably even a little COBOL! So what do you think of that?!  Hello?  Hello?  Did you just hang up on me?!! WTF!

Anyhow…. Hold on, I need to get my dog outside before she has an accident….

okay, I’m back.

Why Invoke it over the Web?

There are several potential reasons for wanting to do this:

  • I was really bored and it’s been raining all freakin day, and…
  • It’s 3am and I can’t sleep, and…
  • I saw this, and …
  • I wanted to pull this off within Azure, using a VM extension, without having to import any actual files, and it would be cool to tie all this together with a runbook so I can send a text message “new lab configmgr p01“, to fire off a lab build in Azure and have it text me back “your stupid lab is ready, now leave me alone!” then I can forget it’s still running and it runs all my MSDN credits down to $0 until the next monthly cycle, and…
  • I scrolled through Dan Bilzerian’s twitter feed just long enough to hate my boring life, and needed a distraction, and…
  • It seemed like something cool to try

Example

Time to put on a poker face and act serious now.  The example below calls the cm_build.ps1 script from the GitHub master branch URL, converts it into a -ScriptBlock object, and passes in the -XmlFile parameter value using the Github Gist raw URL (you can make your own by copying the cm_build.xml into your own “secret” Gist, so you don’t openly share sensitive information to the whole world)

$ps1file = 'https://raw.githubusercontent.com/Skatterbrainz/CM_Build/master/cm_build.ps1'
$xmlfile = '<your-gist-raw-url>'

$script = Invoke-WebRequest $ps1file
$scriptBlock = [ScriptBlock]::Create($script.Content)
Invoke-Command -ScriptBlock $scriptBlock -ArgumentList @($xmlfile, $True, $True, $True)

But you can also invoke the interactive gridview menu using the -Override parameter, by simply appending one more $True into the -ArgumentList array.

Invoke-Command -ScriptBlock $scriptBlock -ArgumentList @($xmlfile, $True, $True, $True)

Then you get this budget-sized, corner-cutting, hack of a menu to choose from…override-gui

You may see a red warning about “Split-Path : Cannot bind argument to parameter ‘Path’ because it is null.”  I’ll fix that soon.  It only impacts the log output, but nobody reads log files anyway, right?

Anyhow, it’s 3:33 am, and I’m still typing, which is probably bad for my health, but if two people read this and it actually provide useful information one of you, mission accomplished.  Actually, I know for a fact this is bad for my health.  Regardless, I ran the above snippet (with a real URL in the $xmlfile assignment) in my Hyper-V duct-tape and chewing gum lab at home, and it worked like a charm.  Now I can log into the server, open the ConfigMgr console and proceed with CM_SiteConfig, or apply real world tactics and break the ConfigMgr site entirely and start over.

zzzz

Advertisements

My Favorite Ignite 2017 Sessions

Just a heads-up: Not all of the sessions I attended or enjoyed most are posted yet.  And some sessions might not have been recorded (expo area mostly).  Also, some of the videos have flaky audio.  Enjoy!

[ PLACEHOLDER FOR ASK THE EXPERTS: WINDOWS 10 DEPLOYMENT AND SERVICING SESSION ]

[ PLACEHOLDER FOR BRANCH CACHE SESSION (when it becomes available) ]

[ PLACEHOLDER FOR EXPERT LEVEL WINDOWS DEPLOYMENT SESSION (when it becomes available) ]

Cm_SiteConfig 1.3 – Importing Queries and Collections

Updated:  Added missing graphic of menu

This may be the only blog post I do before I head down to Microsoft Ignite this coming weekend. I’m also trying desperately to keep up with younger colleagues on exam studying, damn it. Getting old sucks. Anyhow. I wanted to discuss some things about cm_siteconfig 1.3 that I may have glossed over (or snored through). I need a break from labs right now anyway.

What is Cm_SiteConfig?

I’ve been working on a pair of PowerShell scripts to automate the building of a System Center Configuration Manager site server.  This could be a CAS or a Primary, but basically, each of the two (2) scripts uses a dedicated XML configuration file to control what it does.  Cm_Build.ps1 installs all of the prerequisite items to make a vanilla Windows Server machine into a Configuration Manager site server.  It does not configure the Configuration Manager site itself however.  So, things like Discovery Methods, Boundary Groups, Client Settings, Site Settings, Collections, Queries, OSD items, Applications, etc. need to be created.  This is where Cm_SiteConfig comes in.

Cm_SiteConfig.ps1 uses Cm_SiteConfig.xml to configure an existing Configuration Manager site server with things like Discovery Methods, Active Directory Forest Connection and Publishing, Boundary Groups, Site System Roles (multiple), Client Settings, Client Push settings, Distribution Point Groups, Operating System Images, Operating System Upgrade Installers, Collections, Queries, Applications, Maintenance Tasks, System Accounts, Enpoint Protection Policies and even Console Folders in which to organize these things.

The Override Feature

Normally, when each script is run, it processes the XML configuration data in sequential order by reading the “use” property of each item (if use=”1″ it’s processed, otherwise it’s ignored).  When using the -Override parameter, you are presented with a graphical menu, from which you can choose individual tasks to execute, while skipping over the others entirely.

For example, if you wanted to just import custom queries and collections, you can do the following:

  1. Edit the cm_siteconfig.xml file to suit your site configuration (within the [cmsite] tag: sitecode, forest, etc.)
  2. Edit the queries and collections entries (if needed)
  3. Open a PowerShell console on the Site Server using “Run as Administrator”
  4. Run the cm_siteconfig.ps1 script as follows (see example below also):
    cm_siteconfig.ps1 -XmlFile cm_siteconfig.xml -Detailed -Override
  5. Select the features you wish to process from the Gridview menu, and click OK (lower right of menu)
  6. Watch the output and refresh your console

You can do the same with other sections of the XML file.

Important Note!

Be sure to run the Folders section at least once, to insure the folders are created prior to other sections being processed which may rely on those folders to be present.

Where to Get it – Here

Feedback / Suggestions / Bug Reports – Here (please!!)

Back to studying.  I hope to run into some of you during Ignite!  I’m easy to spot:  I look like every other white guy roaming the expo floor with too much swag falling out of every pocket and trying to hold a drink and a cellphone at the same time.

Random Notes from This Week

Warning: Skattered thoughts ensue.

Checking Memory

Calculating total system memory within a virtual machine session might seem like a rather mundane task.  But during a recent troubleshooting call with a customer, I ran across something I had forgotten: Physical machine properties are stored in WMI differently depending upon the context.  Note that running these on an actual physical machine, a virtual machine with static memory allocation, and a virtual machine with dynamic memory allocation, will often yield different results.

Win32_ComputerSystem (TotalPhysicalMemory)

[math]::Round(((Get-WmiObject -Class Win32_ComputerSystem | 
  Select-Object -ExpandProperty TotalPhysicalMemory) | 
    Measure-Object -Sum).Sum/1GB,0)

This returned 4 (GB) from 4,319,100,928

Win32_PhysicalMemory (Capacity)

Using Win32_PhysicalMemory / Capacity returns a different result.

[math]::Round(((Get-WmiObject -Class Win32_PhysicalMemory | 
  Select-Object -ExpandProperty Capacity) | 
    Measure-Object -Sum).Sum/1GB,0)

This returned 16 (GB) from the sum of 17,179,869,184 (13,019,119,616 + 4,160,749,568).

 

PowerShell, CSV and sparse Label Names

Some of the biggest headaches in IT, besides people, are caused by imposing human habits on technical processes.  For example, insisting on embedded spaces in LDAP names, CSV column headings and SQL table columns.  Just stop it!  Say no to spaces.  The only space we need is the one between our ears, and usually when driving.  However, we don’t always have the luxury of dictating “best practices”, instead, we have to adapt.  So, I had a colleague suffering with a CSV file that a customer provided with column names like “Last Name”, “Dept Number”, and so on.  Why they couldn’t use “LastName”, “LName”, or even “LN”, who knows, but it was “Last Name”.

$csvdata = Import-Csv "C:\Program Files (x86)\Microsoft Visual Studio 14.0\DesignTools\SampleData\en\SampleStrings.csv"
PS C:\> $csvdata[0]
Name : Aaberg, Jesper
Phone Number : (111) 555-0100
Email Address : someone@example.com
Website URL : http://www.adatum.com/
Address : 4567 Main St., Buffalo, NY 98052
Company Name : A. Datum Corporation
Date : November 5, 2003
Time : 8:20:14 AM
Price : $100
Colors : #FF8DD3C7

PS C:\> $csvdata[0]."Email Address"
someone@example.com 

PS C:\> $csvdata | Where-Object {$_."Email Address" -like '*fabrikam*'} | 
  Select-Object -ExpandProperty "Email Address"

Thankfully, PowerShell is somewhat forgiving in this regard and allows you to adapt to such challenges easily.  A very small feature but very helpful as well.

Searching for Apps: Slow vs. Fast

Searching for installed software is usually pretty simple.  However, using WMI to query the class Win32_Product often becomes much slower due to overhead incurred by the Windows background refresh.  If you run a query for “SQL Server Management Studio” on a Windows server or client, regardless of the amount of memory, processor power, or disk performance, if these are all equal, WMI will be much slower than searching the registry or file system.  Case in point (using PowerShell for example purposes only):

Get-WmiObject -Class Win32_Product | 
  Where-Object {$_.Name -eq 'SQL Server Management Studio'}

When you run this, if you watch Task Manager at the same time, you may notice WmiPrvSE.exe and dwm.exe spin up more memory until the query is completed.  However, if you search the registry, which may not always be possible for every situation, the performance is typically much better (faster):

Get-ChildItem -Path HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\ -Recurse | 
  Where-Object {$_.GetValue('DisplayName') -eq 'SQL Server Management Studio'}

Another option is to query the file system, which in this example is looking for a specific file and specific version:

$file = "C:\program files\Microsoft SQL Server\140\Tools\Binn\ManagementStudio\Microsoft.SqlServer.Configuration.SString.dll"
if (Test-Path $file) { 
  (Get-Item -Path $file).VersionInfo.FileVersion 
}

Running these three statements on my HP Elitebook 9470m with 16 GB memory and a Samsung 500 GB 850 EVO SSD the results end up with the following average execution times:

  • WMI: 20 seconds
  • Registry: 0.98 seconds
  • File System: 0.13 seconds

The point here isn’t that you should avoid WMI, or anything like that.  It’s just that we should always consider other options to insure we’re choosing the right approach for each situation.  For example, if you really need to invoke the .Uninstall() method, then your options may narrow somewhat.

For a handful of targeted queries it may not matter to you which of these (or others) makes the most sense.  But when querying 5,000, 10,000 or 100,000 machines across a WAN, without the aid of a dedicated inventory product, the choice may have a significant impact.

cm_siteconfig 1.2

I’ve been busy this Labor Day weekend. Besides vacuuming up water from a broken water heater at 4am, mowing a ridiculously big lawn with a ridiculously small lawnmower, and avoiding the oceanfront tourist freakshow (or almost), I spent a fair amount of time on cm_build and cm_siteconfig.  Needless to say, I’m not feeling very funny right now, but I assure you that I will return to my usual tasteless, dry, ill-timed humor after a word from these sponsors.  Even though I don’t have any yet.  Actually, if you blink, you might miss some hidden jestering below.

I’ve already discussed these two PowerShell scripts in a previous blog post, but to update things: cm_build is still at 1.2.02 from 9/2/2017, and cm_siteconfig is now at 1.2.22 from 9/2/2017.  That’s a lot of 2’s.  Anyhow, here’s what each does as of the latest versions:

Note: The version numbers are in parenthesis to indicate lab configuration.  The XML allows *YOU* to configure the installation ANY WAY YOU DESIRE, and to reference ANY VERSION you desire.  The versions below are just what I used to test this thing (so far) about 84 times.

LAB TEST NOTE: Prior to running this script, build the server, assign a name, static IP address, and join to an Active Directory domain.  Then take a snapshot (VMware) or checkpoint (Hyper-V) to roll back if anything spews chunks along the way.

Prep Work

cm_build.ps1 / cm_build.xml

  • Install Windows Server roles and features (except for WSUS)
  • Install Windows 10 ADK (1703)
  • Install Microsoft Deployment Toolkit (MDT) (8443)
  • Install SQL Server (2016)
  • Install SQL Server Management Studio (2017)
  • Configure SQL Server maximum memory allocation
  • Configure SQL Server ReportServer DB recovery model
  • Install WSUS server role
  • Run the WSUS post-install configuration
  • Install System Center Configuration Manager 1702
  • Install ConfigMgr Toolkit 2012 R2
  • Install Recast Right-Click Tools

GENERAL NOTES:  The cm_build.xml structure starts with the “packages” section, which dictates what gets executed and in what order.  The “name” element establishes the package code link used by all of the other sections, such as payloads, detections, files, and features. Note that the files section only requires the pkg key value for SQLSERVER and CONFIGMGR.  Other files can be created without using a matching pkg key if desired.

LAB TEST NOTE: I strongly recommend taking another snapshot (VMware) or checkpoint (Hyper-V) at this point, prior to running cm_siteconfig.ps1.  This will help avoid angst and loss of temper while making iterative changes to cm_siteconfig.xml and retesting.

cm_siteconfig.ps1 / cm_siteconfig.xml

  • Create SCCM accounts
  • Configure the AD Forest connection
  • Configure Server Settings
    • Software Deployment Network Access Account
  • Configure Discovery Methods
    • The template AD User Discovery Method adds AD attributes: department, division, title.
    • The template AD User and System Discovery Methods add filtering for password set and login periods of 90 days each
  • Configure Boundary Groups
    • The template creates 4 sample boundary groups
    • You can enable creating Site Boundaries as well, but the default is to allow the AD Discovery to create subnet/IP range boundaries
  • Configure Site Roles
    • Management Point
    • Service Connection Point
    • Distribution Point (with PXE)
    • Cloud Management Gateway (still in development)
    • Software Update Point
    • Reporting Services Point
    • Application Catalog Web Service Point
    • Application Catalog Website Point
    • Asset Intelligence Synchronization Point
    • (more to come)
  • Client Settings
    • Still in development, but…
    • The template creates two (2) sample device policies: Servers and Workstations
  • Client Push Installation Settings
    • Still in development
  • Create DP groups
    • The template creates 4 sample DP groups
  • Create console Folders
    • The template creates sample folders beneath: Applications, Device Collections, User Collections, Boot Images, Task Sequences, and Driver Packages
  • Create Custom Queries
    • The template creates two (2) sample device queries
  • Create Custom Device Collections
    • The template creates three (3) sample user query-rule collections, and 15 sample device query-rule collections
  • Create Custom User Collections
  • Import OS Images
    • The template imports two (2) OS images: Windows 10 1703 and Windows Server 2016
    • Source media is not included.  Batteries not included.  Just add hot water and stir.
  • Import OS Upgrade Installers
    • The template imports two (2) OS upgrade packages
  • Configure Site Maintenance Tasks
    • Excludes Site Backup, and Database Reindex tasks for now.  I plan to have these enabled soon.
  • Create Application Categories
    • The template includes (5) sample categories: IT, Developer, Engineering, Finance, General and Sales
    • For now, the detection rules are implemented using a chunk of freshly-cut, carefully seasoned, and slow-roasted PowerShell code, because it’s easier to shoe-horn into this process and provide flexibility and adaptability.  And besides, all those syllables sound kind of impressive after a few mixed drinks.
  • Create Applications
    • The template includes examples for 7-Zip, Notepad++, VLC Player, and Microsoft RDC Manager

What’s Next?

  • I’m still working on this, so more changes/improvements will be coming.

Q & A

  • Is it really “open source”?
    • Yes! Go ahead and pinch yourself.
  • Did you write all this code yourself?
    • Yes, sort of.  Some of the pieces were adapted from, or inspired by, the outstanding work done by other amazing people like Niall Brady, Nickolaj Andersen, Johan Arwidmark, Mikael Nystrom, Maurice Daly, Stephen Owen, Anders Rodland, Raphael Perez, Chrissie LeMaire, Jason Sandys, Sherry Kissinger, and many others I can’t think of right now.  Thanks to Kevin B. and Chris D. for helping me find better ways to solve key areas of the overall project.  The XML constructs and process model are my own hallucinatory work.
  • Can I Make Suggestions / Request Changes?
    • ABSOLUTELY!
    • Please use the “Issues” feature in Github to submit bugs, feature changes and enhancements, etc.  I will make every effort to review, assess, feebly attempt, fail to satisfy, cry over insecurities of self-doubt, angrily assign blame, throw objects across room while swearing like a drunk sailor, solemnly accept defeat, and ultimately: try to make it work as requested.
    • Note that creating a Github account is required for submitting Issues.  Github accounts are free and they make you feel warm and fuzzy inside.
  • Does cm_build also download required installation media?
    • No.  I’m too lazy.
    • 99.999999% of my customer engagements involve a ‘kick-off’ call in which we discuss prerequisite action-items prior to beginning work. This typically includes requesting the customer to have all installation media and licensing information ready to go.  Which they typically do, so I didn’t feel the need to bother with that aspect (not to mention, try to keep up with version changes and new URL’s over time)
  • Can cm_build be used to install a Central Administration Site?
    • Yes.
  • Can cm_build be used to install a Secondary Site?
    • Yes.
  • Can cm_build be used to destroy alien civilizations?
    • Probably not.
  • How was this thing Tested?
    • In a small dungeon beneath a floating castle in a lake atop a tall mountain.  Okay, in my home lab, next to the dog’s sofa.
    • It’s been tested about 84 times as of 9/4/2017.  That’s about 55 times for cm_build and 29 times for cm_siteconfig.  But by the time you’ve read this, it’ll have increased again.
  • What was/is your Test Environment like?
    • Windows Server 2016 (Dell R710) server with Hyper-V
    • 3 virtual machines: DC1 (domain controller), FS1 (file server) and CM01 (configuration manager server)
    • CM01:
      • 16 GB memory, 4 disks (C: for OS, E: for apps, F: for content, G: for logs, etc.), 2 vCPUs
      • Windows Server 2016 Standard
    • Me:
      • Coffee cups falling off the desk, on ever flat surface, in the trash can, on top of one of my dogs, and a few more in the kitchen sink
      • Empty snack bar wrappers strewn across the room
      • A tattered doggie toy-squirrel hanging on a door knob for some strange reason.
  • What’s the point?
    • It’s been challenging, and fun, to work on.  It saves me time and headache at work and in my home lab.
    • It opens up potential secondary capabilities, like automating installation documentation and building an extract/build process to close the circle of life, open a wormhole, fill it with black holes and jump in for a ride.  I really need to stop listening to so many podcasts.
  • Why should I care?
    • You shouldn’t.  You can go do something fun now instead.
  • Why XML?
    • Because I &^%$ing hate JSON, and INI is too limited.  I thought about YAML, which looks a little bit like JSON, but not like it was punched in the face with a meat tenderizer mallet, but then I had to mow the lawn, and completely forgot why.
  • What have been (or continued to be) the biggest Challenges?
    • Time
    • Sleep
    • Deciding where to draw logical boundaries between automating and leaving out for manual work later
    • Refactoring, refactoring, re-refactoring, and re-re-refactoring before refactoring some more
    • More refactoring
    • Incomplete Microsoft ConfigMgr PowerShell cmdlet reference documentation*
    • Incomplete/inconsistent Microsoft ConfigMgr PowerShell cmdlet features*
    • Incomplete/inconsistent mental capacity (mine)
    • Occasional power and Internet service outages and lack of a power backup system (budget, weather, drunk drivers)
  • Does humor belong in IT?
    • Yeah.  It has to. Over 35 years in this field of work, I’ve seen what happens to people who forget that. It doesn’t end well.

*  I’m not going to beat them up on this, since they are already making Herculean efforts towards modernizing and cleaning up ConfigMgr, so the gravy should have a few lumps.

cm_siteconfig updates and my humor tank is running empty

I finally got some sleep. And immediately thereafter, I discovered a bug in the script. It’s in the detection method part of the Add-CMDeploymentType mess. The nested PowerShell code inside the @”…”@ stuff was expanded and caused it to wipe out the $reg and $val variables, so the result was like our Federal government today: useless.

Anyhow, upon discovering that, I went to work fixing it, and decided to go ahead and add detection methods for “file:” and “folder:” to add to the existing “registry:” option. This required an additional sample application in the XML file, which I chose VLC player, because, well, why not? VLC is like a lobbyist in DC, it’s everywhere. And yes, you can tell I’m a little perturbed at our ongoing temperamental governmental dysfunctionality reality.

Other changes: added a new -Detailed switch, to display “verbose” output, without using -Verbose, and makes the verbose output much MUCH prettier to read than using -Verbose, which is pretty ugly.

So, after testing is completed, I will upload to the branch “1.2.02” in the Github repo.  Hopefully in the next few hours.  First, I have to take my dog Dory (aka “butt brain” aka “turd beast” aka “no! you can’t eat the cat!”) for a walk.

What is this, cm_build and cm_siteconfig stuff?

UPDATE 8/29/17 – Corrected a mistaken attribution for Driver Automation Tool to Maurice Daly.

I’ve been kind of quiet lately.  Quiet, as compared to how normally chatty I tend to be online, that is.  It’s been a mix of personal life, work life and hobby life.  Personal aside, work life has been a little quiet this week, which is fantastic for catching up on things, and spending a little time with my hobby life: wordworking and coding.  I don’t have a Yankee Home Workshop space or anything, but I get by okay.  If I ever win a massive PowerBall lottery payout, my neighbors will have to relocate, as I will need their spaces for expanded hobby capabilities.

Anyhow, on to the meat and potatoes:  I’ve been toying with this for quite a few years, but could never align the right perception, time allocation and initiative, to make it gel.  This past week and weekend they just happened to align at the right place and the right time.

Why?

I wanted to devise a different approach to specifying the configuration rules in advance and then executing them with limited (or zero) human interaction.  The rules should be the design document.  Or at least the basis of such.  It shouldn’t be difficult to derive the XML data into a readable document, such as Microsoft Word or HTML.  And the code should be reusable and resilient.  Run it as many times as desired (or needed) on a given server and it should ignore what is already done, and only work on what hasn’t been done yet.

The Bundle

cm_build and cm_siteconfig are two (2) pieces of a bundle of scripts aimed at simplifying and streamlining the building and configuration (respectively) of a System Center Configuration Manager site server.  Actually, either a Central Administration or a Standalone Primary, site server.  It’s flexible enough, in theory, to contend with other roles and purposes.

cm_build

cm_build.ps1 is a PowerShell script that reads from cm_build.xml, which contains the logic (configuration data) to take a “vanilla” Windows Server host (virtual or physical) up to having ADK, MDT, WSUS, SQL Server, SQL Server Management Studio, Configuration Manager, ConfigMgr Toolkit and Right-Click Tools (optionally) all ready to go.  The baseline server only needs to be prepared for general purpose server capability (assigned name, static IP address, domain-joined, etc.) and have the proper resources allocated (memory, processors, disks, etc.).  The only other requirement is having the installation media accessible.

The default configuration of the cm_build.xml file refers to a set of UNC shares on a common network, but you could reference a local disk, removable media, or any other source which can be read from using PowerShell.

cm_build is farther along in development and testing than cm_siteconfig.

cm_siteconfig

cm_siteconfig.ps1 works very much like cm_build, in that it reads from cm_siteconfig.xml in order to configure a “vanilla” Configuration Manager Primary or Central Admin site server to whatever you prefer.  This will include:

  • AD Forest
  • Discovery Methods
  • Boundary Groups
  • Client Settings
  • Client Push Installation
  • Queries
  • Collections
  • Applications and Deployment Methods
  • Site Roles: Asset Intelligence, Software Updates, etc.
  • Distribution Point Groups
  • Operating System Images
  • Operating System Installers (upgrades)
  • Console Folders
  • Maintenance Tasks

Of these, the items in blue are ready to test.  The others are in development and moving as quickly as my coffee intake can allow.

What about Other Features?

Software Updates, Endpoint Protection, Windows 10 Servicing, Task Sequences, and so on, are all up for consideration.  However, each of these has some unique aspects that may change whether I try to incorporate them sooner, later or never.  For example, Task Sequences can be exported and imported, and with each new ConfigMgr build, the PowerShell interfaces get more robust, which delves into version impacts and compatibility aspects.  I need to start small and work upward, and start with the more mature stack of tools, which helps insure the broadest platform support.

I’m getting ahead of myself here.  Much of this is obviously predicated on time, initiative, and my own, limited abilities.  Some might call this “pie in the sky” thinking, and it may very well be just that.  Whatever, it’s a nice hobby for me that doesn’t cost a lot of money and I can do it indoors.

What about Drivers?

I’m leaving drivers out of this for now, because Maurice Daly basically blew the doors off of that with this, and I don’t even want to think about reinventing that wheel.  Kudos for that one.  One of many amazing tools he has produced.

Is it done?

No.  But cm_build is fairly stable and tested as of now.  cm_siteconfig is still in development, but there’s enough to kick the tires and see if it leaks transmission fluid on your rug.  It’s free, and it’s open, so that makes it sort of freeopen.  But that could likely be an offensive word in another language.

Where is it?

[Here]

What’s Next?

Who knows.  That’s what makes it fun to mess with.  Kind of like a blind, drunk guy poking at a rattle snake with a pencil.