System Center: Orchestrator Engineering Team Blog

Quick Tip: Enabling Link Text But Getting Rid of “Link”

Robert_Hearn — Mon, 28 May 2012 15:14:00 GMT

If you're like me, you like to put descriptive text in a link to describe what it does. Perhaps it's to indicate the conditions of a branching structure, like this: But what’s annoying is that when you turn on the Link text, every link has the word “Link...(read more)

Want to Use .NET 4.0 with Orchestrator Toolkit IPs? Here’s How!

Robert_Hearn — Fri, 25 May 2012 16:01:00 GMT

One of our most awesome test guys on the Orchestrator Team, Zhenhua Yao, who has delivered such goodies as the TFS IP and a PowerShell IP on our CodePlex site , has done it again! Anyone who has built an IP using the Orchestrator SDK knows that you need...(read more)

More Fun with COM: Importing Integration Packs via PowerShell

Robert_Hearn — Thu, 24 May 2012 16:08:00 GMT

Around the office, we have more and more internal teams that are latching on to Orchestrator and wanting to use it for building all sorts of integrations and automations, but one of the things that comes up from time to time is how to get the ability...(read more)

Understanding IP Installation: What Does Register/Unregister/Deploy/Undeploy Really Mean?

Robert_Hearn — Wed, 23 May 2012 16:06:00 GMT

One of the most foundational activities an Orchestrator admin does is installing Integration Packs. After all, Integration Packs provide the real value to Orchestrator because they allow you to extend its capabilities and let you connect to virtually...(read more)

Private Cloud Demo Extravaganza Videos!

Travis Wright MSFT — Wed, 23 May 2012 03:35:44 GMT

I just noticed that all of these cool demo videos were posted to TechNet Video earlier this month. Check them out to see how System Center 2012 can make managing your private cloud a whole lot easier and better! Private Cloud Demo Extravaganza...(read more)

Upcoming Webcast Series: Bare Metal to Private Cloud

Travis Wright MSFT — Wed, 23 May 2012 02:42:33 GMT

I’ve been spending quite a bit of time with customers over the last 6-12 months helping them plan out and deploy their first private clouds managed by System Center 2012. To help people get started faster I headed into the Enterprise Engineering...(read more)

Working With Relationships in the SCSM Orchestrator Integration Pack

Travis Wright MSFT — Tue, 22 May 2012 23:09:50 GMT

Working with relationships in the SCSM integration pack can be a bit tricky so this blog post is intended to provide some tips. First of all it is really important when working with Service Manager to understand the data model. Have a look at the...(read more)

Quick Tip: Using the “Read Text Log” Activity

Robert_Hearn — Tue, 22 May 2012 16:10:00 GMT

I had someone contact me recently with some confusion about the Read Text Log activity in Orchestrator. It seems that it wasn’t quite working the way they expected and they were left scratching their head. So I put together a quick demo runbook and tested...(read more)

New Exchange Integration Pack On the TechNet Gallery

Travis Wright MSFT — Mon, 21 May 2012 21:23:18 GMT

Bart Timmermans ( blog , @Bart_Inovativ ) , a consultant at Inovativ, has just released an integration pack for Exchange! Here is a graphic of the activities included. You can read more about the integratio pack on his blog or download it...(read more)

Make Your PowerShell Script Activities Go “Splat”!

Robert_Hearn — Mon, 21 May 2012 16:54:00 GMT

There are always interesting shortcuts and magical techniques to discover in PowerShell, and “splatting” is one of them. Splatting allows you to bundle a set of parameters into a hashtable and then simply using it as single parameter to a PowerShell function or cmdlet. For example, instead of specifying a command line with a bunch of parameters in a long command line like this (which could get longer):

Get-WmiObject –computername SERVER-R2 –class Win32_LogicalDisk –filter "DriveType=3" –credential "Administrator"

You can use a hashtable to define parametername – value pairs like this:

$params = @{'class'='Win32_BIOS';
           'computername'='SERVER-R2';
           'filter'='drivetype=3';
           'credential'='Administrator' }

And then all you need to do is specify a command line like this:

Get-WMIObject @params

While initially this may not seem like such a magical solution, the more parameters you have to a script, function or cmdlet, the more elegant this becomes. Now take this concept and apply it to activities in a runbook, either using the Run .NET Script activity or using custom activities built using the Command Line Activity Wizard in the Toolkit. You can imagine that having to create 10 or 20 input parameters or the same number of outputs for an activity can be kind of cumbersome.

Here’s what a custom command-line activity would look like if you called it with 10 parameters:

You can’t even see all of the command line or the parameters in the same screen!

Or, here is what the Run .Net Script activity would look like with 10 output parameters:

Now imagine having to map individual published data items to and from these inputs and outputs across several activities. Well that’s how many people build runbooks with PowerShell. Believe me when I tell you that splatting is WAY easier!

Here’s an example of using splatting. First of all, I’ll start the runbook with an Initialize Data activity in order to gather the 10 parameters I need:

Next I need to convert those 10 individual inputs into a “here-string”, which is essentially a multi-line string:

Now that’s the hardest you’ll have to work in the whole runbook, because from now on, you can really simplify by using splatting. In the next activity I have a function that uses these parameters.In order to use these parameters, I will need to wrap the string that comes from Published Data in a “here-string” again, because when it’s created in the first activity, it’s actually an object type and gets output to string for the databus (but it retains the line breaks). When transferred on the databus it loses it’s “object-like” nature, so it needs to be put into an object again. I then use the “ConvertFrom-StringData” cmdlet to convert the string into a hashtable.

At the end of this script, I just call the function with the following command line:

Test-MyCode @params

Now you might be saying this simple example doesn’t really show me how I would save time with splatting, because I still had to create an Initialize Data activity with 10 parameters, and I had to put in an extra activity to create the here-string before I got to my script. OK, well, you’re right. Sort of. What I *didn’t* have to do was to create 10 special PowerShell input or output parameters like I showed above. I’ve also set myself up for an easier time if I decide to re-user this script activity in a number of other runbooks. I know that whenever I need to re-use it, I can just send it a single parameter as a here-string and it will take care of all the parameters it needs.

I also know that if I need to pass data from one Run .Net Script activity to another, I don’t have to transfer anything other than one parameter, and simply do it as a here-string and then convert to a hashtable for splatting. Now passing data across multiple script activities gets a LOT easier and less time consuming (and less chance for error too).

So be sure to try this out and use it across your own scripting activities!

Using Windows Task Scheduler to Invoke Scheduled Runbooks

Robert_Hearn — Fri, 18 May 2012 23:06:00 GMT

This article is a follow-on to my previous post, Cool Tool: New Command Line Utility to Start a Runbook , where I talked about using the web service to quickly start a runbook with named parameters. Now it’s time to put that into action! Orchestrator...(read more)

Automating Builds of Orchestrator Integration Packs

Robert_Hearn — Fri, 18 May 2012 19:04:00 GMT

From time to time I get questions from partners and some prolific IP developers who want to create IP’s automatically as part of their build process instead of having to go through the wizard each time. This is especially important when you have a lot of activities in the IP and you might be changing stuff around a lot. Inside the Orchestrator team, we automate our builds like this so that we can have nightly builds of the product and all IPs we’re working on. I just published a TechNet Wiki article describing a process you can use to manually create an IP, bypassing the wizard, so that you can plug this into your build process.

Here is the article: Automating Builds of Orchestrator Integration Packs

If you’re one of those who needs to automate your build process, it should do the trick. And, since it’s on the Wiki, you have an opportunity to add more info to it to improve the documentation! Be sure to check it out.

Community Spotlight: Putting a “Send Popup” Activity Back in Orchestrator

Robert_Hearn — Thu, 17 May 2012 16:05:00 GMT

In the previous Opalis release, we shipped a standard activity called “Send Popup”, which used the Windows messaging system to create a popup on a user’s desktop. We removed that activity because the method we used was incompatible with Windows Server 2008 (it only worked on older platforms). However, it was a good activity for testing runbooks and allowed for some limited form of interactivity between runbooks and users.

Stefan Horz, one of our Microsoft Partners and perennial forum-poster, has an Orchestrator community site in German (and he also has posts in English) where he talks about a number of things, including building a custom version of the “Send Popup” activity using nothing more than the Orchestrator Integration Toolkit, a command line, and Windows “MSG” utility.

Check out his blog post here: Building our own Message Activity with Orchestrator Integration Toolkit (OIT).

Quick Tip: Understanding Multi-Value Data and the Databus

Robert_Hearn — Wed, 16 May 2012 16:21:00 GMT

I saw a question in the forums around multi-value data and how someone could pass multi-value data in to a runbook via the Initialize Data activity. I was going to answer the question there but thought it would be better to post an article to reach a broader audience. When dealing with published data on the databus, it’s helpful to know exactly how multi-value data is produced and consumed so you can plan your runbooks accordingly. Actually, it’s kind of simple once you understand it.

First of all, when I say multi-value data, the term refers to multiple occurrences of an activity’s property or properties. You can think of this as a table, an array, or a collection, whatever suits you best. For example, if you ran the PowerShell command:

get-childitem C:\

You would get back a collection of objects, each with several properties. This is multi-value data. You can handle multi-value data in two ways: (1) You can leave it as it is in “collection” form (which is the default behavior), or you can (2) flatten it into a long string of delimited values (like a comma-delimited list).

The way you choose to handle multi-value affects the way the subsequent activities in the runbook are run. If you choose the default behavior, then the next activity will be run one time for each “row” in the data. If you choose to flatten the multi-value data, then the next activity only runs once, but usually you’ll have to do your own parsing of the data to pull out relevant values.

Now here’s the important part: multi-value data exists only in the activity that created it. Huh? What does that mean? It means that when an activity is triggered, it is triggered by a single instance of the data generated from an activity. Multi-value data in its true “collection” form is never sent to an activity. The next activity is triggered with a single value of that multi-value data. Therefore, the only way to pass in an entire collection of data is to have it flattened in some form first. There is no way to pass in an existing collection of multi-value data because every activity expects to receive a single item.

Cool Tool: New Command Line Utility to Start a Runbook

Robert_Hearn — Tue, 15 May 2012 22:45:00 GMT

I was talking with one of the other Program Managers on the team the other day about how he wanted to be able to launch a runbook as part of a remediation task in Operations Manager, and how it would be great if he has some command-line utility that would...(read more)

Community Spotlight: New Tool to “Sanitize” Runbook Exports

Robert_Hearn — Tue, 15 May 2012 15:30:00 GMT

Ryan Andorfer, one of our favorite members of the Orchestrator community, has done it again. He has come out with a new utility to help administrators sanitize their runbook export files.Here’s what Ryan has to say: A ‘difficulty’ we have with migrating...(read more)

KB: "Unknown" activity type displayed in the System Center 2012 Orchestrator Runbook Designer

J.C. Hornbeck — Mon, 14 May 2012 20:41:53 GMT

Here’s a new Knowledge Base article we recently published. This one discusses an issue where one or more activities are displayed as "unknown" when viewing a Runbook in the System Center 2012 Orchestrator Runbook Designer. ===== Symptoms When...(read more)

Quick Tip: Checking PowerShell Scripting Abilities on a Computer

Robert_Hearn — Mon, 14 May 2012 16:59:00 GMT

I do lots of PowerShell scripting, both inside runbooks and in stand-alone scripts. I have my own little virtual lab with a bunch of VMs and a domain controller that has a group policy assigned to enable the right PowerShell scripting settings on all the domain-joined computers, so I really don’t run into execution policy issues when remoting. However, I always see questions by people who are running into this issue because they live in the real world where computers come with remote scripting disabled by default or where unsigned scripts are not allowed. So rather than have runbooks fail because the right execution policy is not enabled, you should perform a check in your runbook before you do any PowerShell remoting and script running to a remote computer.

Note: if you don't know how to set group policy to enable PowerShell remoting,see this blog post:
Enable and configure Windows PowerShell Remoting using Group Policy

See this page on TechNet for more info on PowerShell execution policy:
http://technet.microsoft.com/en-us/library/dd347628.aspx

So here’s a quick example of testing the ability to run remote scripts on a computer that you can insert into any runbook to head off issues before they occur. You can take this runbook and insert it anywhere in any runbook just by using the Invoke Runbook activity and calling it like you would a function or a method in coding terms. Or, you can just cut and paste the script into a Run .Net Script activity in an existing runbook.

It's really very simple. all you have to do is do an "Invoke-Command", specify the target computer, and the command "Get-ExecutionPolicy". You can then parse the results for whatever execution policy value you're looking for. This simple workflow contains an Initialize Data activity, a Run .NET Script activity, and a Return Data activity.

The Initialize Data activity is there to accept an input parameter of the computer name, which is then used by the Run .Net Script activity (which I renamed Get-ExecutionPolicy to be more like PowerShell). The Return Data activity then passes the execution policy value back up to a parent runbook (if any). The script that’s run is really very simple (I’ve added additional error checking for issues mentioned below):

Now just add a published data property so the value returned in $ExecutionPolicy can be used in the runbook:

If the script succeeds, it will return the execution policy value, which will be one of the following:

Restricted
AllSigned
RemoteSigned
Unrestricted
Bypass
Undefined

This script also catches errors that might occur because of firewall issues. For example, it will trap the following error and cause the object to end with a "failed" status:

Using this workflow, you can be sure that your target computers are correctly configured to accept remote PowerShell commands before you start sending them!

Understanding Sequential vs. Parallel Processing of Runbook Activities

Robert_Hearn — Fri, 11 May 2012 16:46:00 GMT

I saw a question in the forums the other day by a person who asked how you should expect activities in a workflow to be executed when one of the activities generates multi-value data. In other words, one of my activities returns a list of things. How do the next activities react? Will they run in parallel or will they run sequentially? The answer, like so many things, is that it depends. It depends on how you have the activities in your runbook structured.

Let’s start out with the simplest case. I have a Run .Net Script activity that runs the following command:

$collection = gci C:\ | Select Name

It then publishes the variable Collection to the data bus so that subsequent activities can access the data. When this activity runs, it returns a list of files and directory names, which is returned as multi-value data (a collection or list of data items). In the simplest scenario, there is just one activity following the Run .Net Script activity. I’ll use a “Send Event Log Message” activity because I won’t have to deal with any file locking issues if I was writing to a file and activities are running in parallel.

Now let’s assume that the script returns a list of 10 items. This causes the next activity to run 10 times, but does it run sequentially or in parallel? The answer is that they run sequentially.

Within a single runbook, you can think of the process flow like passing a token from activity to activity. Generically, an activity can only handle one token at a time. Some activities take in one token and generate multiple tokens, as in the above example, the Initialize Data activity sends one token to the Run .Net Script activity, which generates 10 tokens from the result of the script (or it could generate just 1 token if you had the “flatten” setting checked). However, it doesn’t pass all 10 tokens off to the next activity at once, it has to pass them one at a time. When the next activity passed on the token to the activity after that (or it “falls off the end of the runbook”), it can accept another token.

So what happens when you have even more activities following the one that generates multiple values? Take the following example:

What happens here is not quite what you might expect from the previous description. When these activities run, the Run .Net Script activity generates 10 tokens and passes them off, one by one to the first Send Event Log Message activity as that activity processes them. The interesting thing is that the first Send Event Log Message activity doesn’t immediately pass off the token to the next activity. It holds on to all of them until it’s done receiving them from the Run .Net Script activity and after it processes the last one, then it starts sending to the next activity. So the process looks like this.

Initialize Data
Run .Net Script
Send Event Log Message
Send Event Log Message
Send Event Log Message
Send Event Log Message
Send Event Log Message
Send Event Log Message
Send Event Log Message
Send Event Log Message
Send Event Log Message
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message (2)
Send Event Log Message (2)
Send Event Log Message (2)
Send Event Log Message (2)
Send Event Log Message (2)
Send Event Log Message (2)
Send Event Log Message (2)
Send Event Log Message (2)
Send Event Log Message (2)

As long as you understand that this is the way it works, then this isn’t a surprise to you and you can build your runbooks appropriately around this functionality. What about branching in multiple directions from an activity at the same time? Do those operate in parallel? Well, because they’re still in the same runbook, the answer is no. Take the following runbook:

When this runbook executes, the activities run in this order:

Initialize Data
Run .Net Script
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message
Send Event Log Message (2)
Send Event Log Message
Send Event Log Message (2)

In this instance, the Run .Net Script activity alternates the tokens it sends out to each direction in the outbound links. Ok, you might be asking what happens when you combine the two versions and have a branch structure with multiple subsequent activities? Something like this:

In this example, I am using Run .Net Script activities to write to the event log because I can control the source name better and provide more readable output when looking at a lot of events. So what happens when I run this? Here’s what the event log looks like:

As you can see, the pattern follows the original branched runbook model I showed before, alternating back and forth from branch 1 to branch 2 until it finishes sending tokens out from the main script activity. It then combines the functionality of the previous multiple following activities example in that each “A” activity (1a and 2a) collects all the tokens until there are no more being received, and then sends them to the next activity, and the branches again alternate so that activities 1b and 2b are run in alternating fashion until the entire runbook is done.

So what you can expect from this is that when you have a non-exclusive branch (also called a split) where both sides are run without conditions or where both conditions are true, you will end up running activities in an alternating manner up until they rejoin via a Junction activity.

Just to take it one step further (because I wanted to know), what about when you have multiple branches in a runbook? How does that work? Here’s an example:

Now look at the event log:

The same pattern emerges that all the “A” activities are done first, then the “B” activities are done. However, note how the second branch is handled. When it hits the second branch, “branch 1” now does two activities for every one activity “branch 2 runs”. This means that when an activity runs and passes on its token(s) to the next item in the runbook, it will actually evaluate all the outgoing link conditions and process those as a set before relinquishing command to the other branch.

Parallel Processing

So how do you get the runbook process things in parallel? Well, within a single runbook, you can’t do it. It takes a combination of a parent and child runbook, and even then, it’s not *truly* parallel, it’s *mostly* parallel. I’ll explain…What you have to do is place the activities you want to run in parallel in a separate runbook, and then use the Invoke Runbook activity to call it.

You’ll then need to do two more things. First, you need to make sure that the Invoke Runbook activity has the “Wait for Completion” box unchecked.

Next, you’ll need to set the properties of the child runbook to allow multiple concurrent runbooks to be executed. Right-click on the runbook tab and select Properties, and then click on the Job Concurrency tab and set the number of concurrent runbooks allowed to a higher number.

Note: the number you set here can still be limited to a maximum number of overall running runbooks on the Runbook Server as determined by the throttling limit. For more info on that setting, see How to Configure Runbook Throttling.

When you leave the “Wait for completion” box unchecked, it basically triggers the other runbook to start, and as soon as it does, it considers the action complete and starts the next one, regardless of where the previous one is in its execution. So while the starting of the child runbooks happens sequentially, it happens so fast that it’s nearly parallel, and because each of the child runbooks runs in its own policymodule process, it can run independently of the others, and can run in parallel. Here is the event log output from the above runbooks:

As you can see, every instance of the child runbook ran and created an event log entry within the same second. If that’s not parallel execution, I don’t know what is

So hopefully this has given you a better understanding of how runbook activities flow and how data passes across them in a runbook. Feel free to create your own test runbooks and try out your own scenarios.

Open Beta for Private Cloud MOF Guide - Now Available for Download!

Travis Wright MSFT — Fri, 11 May 2012 03:53:41 GMT

Managing and Operating a Microsoft Private Cloud—How to Apply the Microsoft Operations Framework (MOF)

The Microsoft Operations Framework team is working on a new guide: Managing and Operating a Microsoft Private Cloud—How to Apply the Microsoft Operations Framework.

Get the beta here.

This guide leads you through the process of how to manage and operate a Microsoft private cloud using the service management processes of the Microsoft Operations Framework (MOF). The guide applies MOF’s IT service management principles to that conceptual architecture and technology stack. It describes how to maximize the potential of MOF’s people, process, and technical capabilities to manage and operate a Microsoft private cloud.

Follow this guidance for a private cloud that is better aligned to meet your business needs. Employ MOF’s service management functions (SMFs) to help align IT and business goals, which can enable you to perform private cloud activities effectively and cost-efficiently.

This guide focuses on the SMFs in the Operate Phase and the Manage Layer of MOF to give IT pros and managers what they need to know about managing and operating a private cloud. Management reviews—internal controls that ensure goals are met to achieve business value—are also included.

Tell us what you think! Download and review the beta guide, then send your feedback to mofpm@microsoft.com by June 11, 2012. We would especially appreciate feedback in the following areas:

· Usefulness – Is the technical depth of this guide sufficient for the topics covered? Will this guide be useful to you on a day-to-day basis? What portions of the guide are the most useful to your organization?

· Usability – Is the structure or flow of this guide effective? Is the information presented in a clear and logical manner? Can you easily find key content?

· Impact – Do you anticipate that this guide will save you time and accelerate deployment of Microsoft products in your organization? Has this guide had a positive influence on your opinion of the Microsoft technologies it addresses?

Benefits for participation:

· You get an early look at the guide.

· You will be listed on the acknowledgments page for providing usable feedback.

We look forward to hearing from you! Your input helps to make each guide as helpful and useful as possible. Thanks in advance for taking the time to review Managing and Operating a Microsoft Private Cloud—How to Apply the Microsoft Operations Framework (MOF).

Subscribe to the MOF beta program and we will notify you when new beta guides become available for your review and feedback. These are open beta downloads. If you are not already a member of the MOF Beta Program and would like to join, follow these steps:

1. Go here to join the MOF beta program:

https://connect.microsoft.com/site14/InvitationUse.aspx?ProgramID=1880&InvitationID=MOFN-M6H9-PV3X

If the link does not work for you, copy and paste it into the web browser address bar.

2. Sign in using a valid Windows Live^® ID.

3. Enter your registration information.

4. Continue to the MOF program beta page, scroll down to Microsoft Operations Framework, and click the link to join the MOF beta program.

Please send your comments and feedback to mofpm@microsoft.com.

Want to learn more about other MOF guides?

Visit our MOF page for information on the full series of Microsoft Operations Framework guides.

Check out our other Solution Accelerators:

You can see our full catalog of Solution Accelerators here.

Questions & Feedback:

For Microsoft-internal questions and feedback on the guide, please contact us.

FAQ: Cloud Service MP Pre req error: The current user is not a valid System Center Orchestrator user

Travis Wright MSFT — Thu, 10 May 2012 17:09:07 GMT

Did you get this error message when trying to import the Cloud Service MP runbooks into Orchestrator?

This is because the Cloud Service MP is not actually testing to see if the user that is running the setup actually has the required permissions by asking Orchestrator. It is looking for something very specific: It wants to see if the logged in user is directly a member of a local security group called OrchestratorUsersGroup. You must also be running the setup on a Orchestrator management server.

Regardless of how you configured security for Orchestrator you need to have the logged in user be a member of a local group on the server called ‘OrchestratorUsersGroup’ in order to get past the prereq checker.

The Orchestrator setup explicitly recommends using a domain group to grant permissions so assuming people are following instructions I expect quite a few people will hit this when installing CSPP.

Default:

Normally should be changed to a domain group…

Of course, you still need to have permissions to write to the root folder in order to be able to create a new folder and import the new runbooks but you can actually get those permissions from however you configured it when you set up Orchestrator – probably by using a domain group and putting your user account in it.

Cloud Service Process Management Pack RTM Now Released!

Travis Wright MSFT — Thu, 10 May 2012 16:57:11 GMT

Enhance private cloud management with new process pack

Microsoft System Center Cloud Services Process Pack now available for download!

The Microsoft Solution Accelerators team is pleased to announce that the System Center Cloud Services Process Pack is now available for download.

Download the System Center Cloud Services Process Pack.

The System Center Cloud Services Process Pack is Microsoft’s Infrastructure as a Service solution built on the System Center platform. With the System Center Cloud Services Process Pack, enterprises can realize the benefits of Infrastructure as a Service while simultaneously leveraging their existing investments in the Service Manager, Orchestrator, Virtual Machine Manager, and Operations Manager platforms.

Corporate datacenters are in transition. The recent shift from physical to virtual environments is now being replaced by an interest in moving to the cloud—specifically both private and public cloud infrastructures. Private cloud management assets are being delivered with System Center 2012 and a key part of this solution is the self-service experience. This experience is now significantly enhanced by the System Center Cloud Services Process Pack.

The benefits offered by System Center Cloud Services Process Pack for the enterprise include:

Deep customization and extension of the cloud services experience; natively supported by the System Center suite of products.
Reduced cost, effort, and time to deploy cloud services to organizations that already leverage the System Center platform.

The benefits offered by System Center Cloud Services Process Pack for consumers of IT within the enterprise include:

Standardized and well-defined processes for requesting and managing cloud services, including the ability to define Projects, Capacity pools, and Virtual Machines.
Natively supported request, approval, and notification to enable businesses to effectively manage their own allocated infrastructure capacity pools.

The System Center Cloud Services Process Pack offers a self-service experience to facilitate private cloud capacity requests from your business unit IT application owners and end users, including the flexibility to request additional capacity as business demands increase.

Download the System Center Cloud Services Process Pack: Download the process pack.

Learn more. Visit our TechNet Library page to learn more.

Tell your peers about Solution Accelerators! Please forward this to anyone who wants to learn more about Microsoft Solution Accelerators.

Already using Solution Accelerators? We’d like to hear about your experiences. Please send comments and suggestions to satfdbk@microsoft.com.

System Center

System Center 2012

Microsoft Private Cloud

Want to learn more about Solution Accelerators?

Visit our Solution Accelerators home page to discover how these tools can help your organization save time and money.

Check out our other Solution Accelerators:

View our full catalog of Solution Accelerators.

Send us your feedback:

Please send your comments

and feedback to cloudservicesfdbk@microsoft.com

Follow us on Twitter!

Get the latest tips from Solution Accelerators—in 140 characters or less! @MSSolutionAccel

Psst! Here’s a Secret Way to Customize the Runbook Tester Window!

Robert_Hearn — Thu, 10 May 2012 16:32:00 GMT

If you’re like me, you use the Runbook Tester a lot. And, if you’re like me, you get annoyed by always having to resize the window to maximize one area or another. For me, I use the logging section more than anything, so I want to maximize the size of that part of the window. I also want the Runbook Tester to start out maximized instead of just some arbitrary size. Well, those that know me well know I am a hacker by nature and I like to “see what I can do” with stuff. I’ll poke and prod things to find out how they work and find out how I can tweak them. Of course, having access to the source code doesn’t hurt .

Note from the legal dept: The process described here is not officially supported by Microsoft and are provided only as an example to the community.

Neither I nor Microsoft, nor any other person, animal, vegetable or mineral assumes responsibility for the process demonstrated here. USE AT YOUR OWN RISK!

One day I got an itch to fix my Runbook Tester the way *I* wanted it. I noticed that when I started Runbook tester for the first time, it created a settings file in my local AppData directory:

C:\Users\<username>\AppData\Local\Microsoft System Center 2012\Orchestrator\RunbookTester.config

Opening that file, I noticed it was plain XML and had some elements that looked like sizing and coordinates:

<DebuggingConsole>
   <East.size>200</East.size>
   <LastPolicy></LastPolicy>
   <Show.State></Show.State>
   <South.size>200</South.size>
   <West.size>200</West.size>
   <Workspace.Bottom></Workspace.Bottom>
   <Workspace.Left></Workspace.Left>
   <Workspace.Right></Workspace.Right>
   <Workspace.Top></Workspace.Top>
 </DebuggingConsole>

So I decided to play around with those numbers. What I discovered was that I could maximize the window by default by setting “Show.State” to 3, and I could shrink or expand the docked areas by changing those numbers. For example, I set the values to the settings below and got the following result:

<DebuggingConsole>
   <East.size>0</East.size>
   <LastPolicy></LastPolicy>
   <Show.State>3</Show.State>
   <South.size>500</South.size>
   <West.size>0</West.size>
   <Workspace.Bottom>950</Workspace.Bottom>
   <Workspace.Left>0</Workspace.Left>
   <Workspace.Right>1200</Workspace.Right>
   <Workspace.Top>0</Workspace.Top>
 </DebuggingConsole>

As you can see, the screen is now weighted heavily to the runbook diagram and the log. If I change the “South.Size” value to 900, I get a view that’s almost entirely the logging section. Note that when you set values for “West.Size” (the Run Time Values and Design Time Values panes) and the “East.Size” (Resource Browser pane) to zero, these panes don’t disappear, they just shrink to their minimum sizes.

However, you can see that by adjusting the numbers, you can get the panes to suit not only your monitor but your own way of using the Runbook Tester. Play around with it and set it how you want it! Enjoy!

A Quick Look at the New PowerShell Activities in the DPM and VMM IPs

Robert_Hearn — Wed, 09 May 2012 16:09:00 GMT

When we on the product team create an integration pack for a product, whether it’s for System Center or another Microsoft products, or even a 3rd-party product, our goal is not to try and replicate everything that product does in the form of runbook activities. First of all, not everything a product does makes sense to try and automate because they might only be done once or twice in the lifetime of the installation. What we do is try to cover core scenarios with activities that help accomplish what data center admins need to do on a regular basis.

The second reason why we don’t do that is scalability. When our runbook activities are a combination of multiple actions on the target product, it requires new effort to develop and release each additional activity, and we simply cannot scale to provide quality integration packs that contain 50 or 100 activities, let alone cover the 466 PowerShell cmdlets available in the latest release of VMM.

This is why, in the integration packs for System Center 2012 Data Protection manager and Virtual Machine Manager, we include new activities for running free-form PowerShell scripts. These activities are designed to allow you the flexibility to do use any of the PowerShell cmdlets exposed by the product in a way that’s much easier to use than the Run .NET Script activity. These activities, “Run DPM PowerShell Script” and “Run VMM PowerShell Script” take advantage of their integration with the DPM and VMM IPs to offer some benefits over Run .NET Script:

They re-use the connection configuration you’ve already specified for DPM or VMM, so you don’t have to expose any server names or credentials in a script.
They automatically handle running the commands locally or remotely, depending on where your admin console is installed and specified in the connection settings
When possible, they re-use existing PowerShell runspaces and connections to remote computers, improving performance and reducing the amount of connections into your remote computers.
They allow up to 20 output variables to be published to the data bus simply by specifying the variable name on the properties page.

Using the activity is pretty simple. Just put your PowerShell script in the “PowerShell Script” property (I know, it seems obvious). Your script can be a single line command or it can be a full script. Hint – since the view limits you to a single line, you should always right-click and select Expand to get a bigger window to enter your script.

In this simple script, I’m just getting a VMM Server object and returning the Port property from it into a new variable called $portnumber. Then I just put portnumber as an output variable to enable publishing that value to the data bus.

Note: you can use “portnumber” or “$portnumber” and either one will work.

When I run the activity in the Runbook tester, I can see the property value is output to published data:

Wasn’t that simple? No longer will you have to create PSCredential objects and set up remote sessions and Invoke-Command. It’s all taken care of for you behind the scenes!

So when you’re using the DPM or VMM IPs and you need to do something that the IP doesn’t provide a discrete activity for, think of the PowerShell script activities in the IP and how those could be used to fill those gaps.

Microsoft Application Approval Workflow (RTM) Now Available!

Travis Wright MSFT — Wed, 09 May 2012 14:59:44 GMT

Enhance your Application Approval Process

The Microsoft Solution Accelerators team is pleased to announce that the Application Approval Workflow Solution Accelerator is now available for download!

· Download Application Approval Workflow

Application Approval Workflow (AAW) takes an application request submitted through the System Center 2012 Configuration Manager Application Catalog and transforms it into a System Center 2012 - Service Manager service request, allowing flexible approval lists and activities.

Key features:

· Synchronize Configuration Manager applications data into the Service Manager database.

· Monitor and transport Configuration Manager Application Catalog requests requiring approval to Service Manager and open a service request.

· Return the completed approval workflow status to Configuration Manager for handling.

· Allow administrators to define and maintain application selection criteria for specific applications or application groups and specific users or user groups.

· Track application approval service requests and view application catalog contents in Service Manager.

AAW extends your application approval process. End users can easily request applications on-demand directly through the Configuration Manager Application Catalog or via redirection from the Service Manager Self-Service Portal. Application requests requiring approval are routed to Service Manager where custom approver lists and activities can be configured based on user and application properties.

Download Microsoft Application Approval Workflow.

Already using Application Approval Workflow? We’d like to hear about your experiences. Please send comments and suggestions to aawfeedback@microsoft.com.

Microsoft System Center

Microsoft Solution Accelerators

Check out our other Solution Accelerators:

View our full catalog of Solution Accelerators.

Already using Solution Accelerators?

Tell us your story. Please send your experiences to aawfeedback@microsoft.com.

Follow us on Twitter!

@MSSolutionAccel