Automating and Managing BizTalk Server 2013 with PowerShell

By Nick Hauenstein

This post is the ninth in a weekly series intended to briefly spotlight those things that you need to know about new features in BizTalk Server 2013.

A lot of people want to be able to manage BizTalk Server from the command line or from within scripts – it is enterprise level server software after all. In the search for the right tool for the job, it seems most reach for the old stand-by BtsTask utility. Some come to realize that BizTalk Server also has pretty decent WMI support (wrapped around the Microsoft.BizTalk.ExplorerOM.dll assembly). Even fewer realize that BizTalk Server 2013 provides a nice PowerShell alternative (out-of-the-box) to that WMI interface that can be used to fully control your BizTalk installation. In this blog post, we will examine how to make use of that new functionality and we will see how we might also accomplish the same things in BizTalk Server 2010.

NOTE: The focus of this week’s post is as of yet undocumented in the official product documentation :-(

If you spend enough time rummaging through the installation directory for BizTalk Server, you will inevitably eventually locate the figurative gold mine of tools that live in the %PROGRAMFILES(X86)%Microsoft BizTalk Server 2013SDKUtilities folder:

image

One of those folders recently caught my eye, as it was absent from my BizTalk Server 2010 installations – specifically the PowerShell folder.

image

Inside, one finds that this folder contains the soafactory PowerShell Provider for BizTalk. This is actually a project that wasn’t initiated by Microsoft, has some history before BizTalk Server 2013, but has now found its way to be bundled alongside the other Utilities in the SDK – and I couldn’t be happier about that.

Getting Started

In order to get started, fire-up the readme.txt, and follow along with the instructions listed:

  1. Open a command prompt as an administrator
  2. Change the directory to the folder containing the binaries
  3. Run the following command to install/register the dlls:
    %windir%Microsoft.NETFrameworkv4.0.30319InstallUtil.exe .BizTalkFactory.PowerShell.Extensions.dll
  4. Open a powershell console as admin in x86 mode and set execution policy as remote-signed:
    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
  5. Add the PS snap-in using the usual approach:
    Add-PSSnapIn -Name BiztalkFactory.PowerShell.Extensions

What Do I Get?

Any time that you add a PowerShell Snap-in, there is actually a relatively easy way to find out what new powers (in the form of cmdlets) that it gave you. If you’re not familiar fully with PowerShell, each cmdlet returns objects – not just strings of text that spill forth from the console. As a result, we can use a cmdlet called Get-Command to get a list of commands that are available, and then filter that list based on a specific property that each item in the list may have. In this case, the property that we want to filter on is the ModuleName (to see a listing of all the properties we could filter on use Get-Member | Get-Command).

I know some of you right now are saying, “Just tell me what to type so it will tell me what it gave me already!” So, here you go (here I’m using BizTalk* in place of typing the full name of the snap-in, so that you don’t have to type as much):

Get-Command | where { $_.ModuleName -like "BizTalk*" }

As you can see, you now have quite a bit of control of your BizTalk group at your finger tips:image

So how do you know how to use each of these cmdlets, and what it does? In the days before PowerShell, you may have typed something like this to see a given command’s (an executable of some kind) help screen and usage:

commandname.exe -?

Given that cmdlets aren’t actually independent .exe files, that’s not going to do you much good. Instead, PowerShell provides you a common way to access the documentation for any cmdlet through the use of the Get-Help cmdlet. Here’s an example:

Get-Help Enable-ReceiveLocation

Unfortunately, you may notice rather quickly that these particular cmdlets are lacking in the documentation department:

image

Traversing a BizTalk Group

Another interesting thing about PowerShell is the concept of providers themselves. They have the ability to provide visibility into the worlds of specific technologies. To be more specific, consider your hard drive. We think nothing of opening a command prompt and being able to type something like dir to see into that world and retrieve a listing of files. In PowerShell, dir is actually a helpful alias for the Get-ChildItem cmdlet (which is technically, again, returning a listing of objects).

If you happen to get a listing of PowerShell providers using the Get-PSProvider command, you will find that the snap-in we added also added a new world for us to explore:

image

In order to get to the world of BizTalk and start looking around, we can do things as simple as typing and executing the following:

cd BizTalk:
dir

image

I can then continue to naturally interact with what I’m presented, and navigate into the Applications “directory”, and then into a specific application I may have installed:

cd Applications dir

cd ‘.Which Runs Fastest’

image

image

Interacting with an Item

So that’s cool that we can see a listing of items in a given scope within our farm, but how can we actually interact with it? For that, PowerShell gives us the Get-Item cmdlet. As an example, consider my installation wherein I have the Which Runs Fastest application. I can back up to BizTalk:Applications and then perform a Get-Item on that application. Likely when I do that, I want to store it in some sort of variable so that I can then interact with that. So I am going to do that with the following:

$myApp = Get-Item '.Which Runs Fastest'

From there, I can investigate both the properties and methods (operations) that I can use to interact with that application using the Get-Member cmdlet:

image

So let’s try to make use of the Orchestrations property shown to give us a listing of Orchestrations alongside their ports (some prior investigation into that property using Get-Member was done for this one):

$myApp.Orchestrations | Format-Table FullName,Ports

image

Here we told PowerShell to provide us with a table formatted list by enumerating the values returned by that property, and then for the objects returned to show us the value of the FullName and Ports properties on those objects.

The sky is the limit though. You have full and scriptable access to the world of BizTalk, and the power of PowerShell at your disposal!

Take it to the Next Level

If you’re hungry for more and want to see more about how you can use PowerShell to manage your BizTalk environments, come join us for one of our upcoming BizTalk 2013 Administrator Immersion classes and you won’t regret it :-)

BizTalk Server vNext TAP Program

By John Callaway

We are pleased to announce to our customers and partners
that we will once again be participating in the Technology Adoption Program
(TAP) for the next version of BizTalk Server. Microsoft has yet to announce a
final name for the product, it is presently being referred to as BizTalk Server
2010 R2 or simply v-next, however they have indicated that the release date
will be about six months after the release of Windows 8 Server. I recently
posted another blog that talks about the future of BizTalk, check it out.

The TAP program assists Microsoft in soliciting feedback
from customers and partners regarding yet to be released products. As
participants in the TAP program we will be under strict non-disclosure
requirements so we won’t be able to say too much about the product until
Microsoft does, but rest assured that we will providing all the feedback that
we can to get all the cool features into the product that we have been looking
for.

 

 

QuickLearn has previously participated in the TAP program
for other versions of BizTalk and for Windows Azure. We will be prepared to
offer training on whatever new features are coming down the line as soon as the
product is fully baked!

 

BizTalk is Dead? Long Live BizTalk!

By John Callaway

The BizTalk Server team blog sneaked out an announcement yesterday that you might have missed. I caught it due to an RSS feed. BizTalk Server 2010 R2 is coming. Now the question is when, and a better question will they change the name, as they should to BizTalk 2011?

We have a while to wait, no firm dates yet, but since it adds support for Windows Server 8 and SQL Server 2010 (codename Denali) which don’t have announced release dates yet either, that isn’t too much of a surprise. They are saying about six months after those products release. Support for Visual Studio 11 was also part of the announcement.

It doesn’t sound at all earth shattering, more just a bit of a jiggle. It may calm some of the fears as they are frequently bandied about from the title of the article, that BizTalk is a dying breed. Rest assured that QuickLearn will be on the forefront of training for this new product as soon as a beta is available.

In addition to support for the new platforms another point of interest is a change to licensing making it possible to provide BizTalk as a hosted service , and to transfer a license to a hosting provider. This is obviously a step in moving BizTalk into the cloud, a change that has long been planned. We’ll have to see what that means as to whether Microsoft will be a possible provider themselves (a la Office 365 and SharePoint online).

That’s about it for what’s new unless you are interested in IBM host integration there are some adapter improvements that way. For the whole article check out the BizTalk Team blog at http://blogs.msdn.com/b/biztalk_server_team_blog/archive/2011/12/08/biztalk-server-2010-r2.aspx

Until next time, see you in the funny papers.

New BizTalk 2010 Training from QuickLearn

By Rob Callaway

Last year was a busy teaching year for me. I taught 35 BizTalk training courses to over 385 BizTalk developers and admins around the world. I received lots of great feedback from our students on ways to improve on our BizTalk Server training. This has resulted in complete rewrites of our BizTalk 2010 Developer Immersion and BizTalk 2010 Developer Deep Dive to make our BizTalk Server 2010 courses even better than ever. Here is a summary of what’s new in these two classes…

BizTalk 2010 Developer Immersion

This class is still intended for students who are new to developing BizTalk Server solutions. However, we have re-written all of the hands-labs to provide a less-traditional end-to-end scenario that I think students will really enjoy working with. We’ve also abandoned the use of step-by-step instructions in later labs. Essentially, we show students how to perform a task one time and then make the assumption that they will be able to repeat the process on their own as they progress through the course. This learning style changes the dynamic of the labs and requires students to apply what they have learned instead of just following written instructions. This makes the lab experience more challenging and much more rewarding.

Also, we have added optional challenge labs for students who want to dive deeper into more advanced BizTalk development topics during open lab time or by remoting into our lab environment after hours. For example, we have challenge labs for students who want to learn about EDI integration, how to process HIPAA healthcare documents, how to write application deployment scripts, and many more. We have also added new modules that cover tracking and troubleshooting of BizTalk run-time errors and BizTalk project planning and management.

BizTalk 2010 Developer Deep Dive

In the past we have had some problems with the leveling for the Deep Dive class. We kept getting too many students with little or no experience with BizTalk, who were not prepared for an advanced BizTalk course. As a result, students were often left behind or the instructor had to water down the training to meet their needs.

After much deliberation we finally decided that it was time to make the Deep Dive class exactly what it should be, very advanced! In this class we absolutely hit the ground running. There’s no time for “introduction to…” conversations. We assume that students already know everything that is taught in the BizTalk Immersion class and crank the dial to 11 with over 30 hands-on labs! We cover all the fun things in BizTalk like: custom components (pipeline and functoids), loosely-coupled orchestration patterns (call/start orchestration shapes, direct-bound ports), convoys, calling pipelines in orchestrations, failed message routing, and more. In fact, this is probably the most fun I’ve ever had while teaching a BizTalk class.

Whether you are new-to-product or a seasoned BizTalk developer, we have the best training to fit your needs. Check out 2011 training calendar for upcoming classes.

kick it on DotNetKicks.com

Automated Deployment and Testing of BizTalk Server 2010 Applications

By Nick Hauenstein

Back when BizTalk Server 2009 was released, there was a lot of buzz about the new integrated support for unit testing of schemas, maps, and pipelines, and cleaner support for automated builds driven by Team Foundation Server (TFS). These were definitely welcome additions that made it much easier to enable continuous integration with automated build and testing. However, there were some things missing. In this article, I’ll review the current state of automated build and testing capabilities that exists for BizTalk Server 2010 when using Visual Studio 2010 Team Foundation Server (TFS). I will first examine the items lacking out of the box, and then direct you to community projects that can improve the situation.

When it comes to the built-in unit testing support in BizTalk Server 2009 and 2010, there are still some areas lacking. For example, testing schemas with imports yielded erroneous results, as all of the necessary schemas were not used in validation. Testing pipelines cannot be accomplished purely in memory with the API exposed. There was not really any work done to enable integration and functional testing of orchestrations. Finally, the automated build process did not take into account the necessity for the bits that were compiled to be deployed somewhere for testing — possibly due to the lack of functional and integration testing support for orchestrations (i.e., there would be no reason to deploy bits that could not be tested anyway).

Thankfully, community efforts filled in most of these gaps for BizTalk Server 2009, and indeed in most cases these community projects preceded the implementation of automated build and testing support in BizTalk Server. Pipeline, pipeline component, and flat-file schema testing was made much more elegant with Tomas Restrepo’s PipelineTesting library. Functional and integration testing of orchestrations was provided for in BizUnit, and automated deployment in preparation for test could be enabled using the bLogical Custom Tasks.

You may have used one or all of these community tools when setting up an environment with BizTalk Server 2009 and Team Foundation Server 2008, and it is still possible to use most of the functionality offered by these in BizTalk Server 2010 and Team Foundation Server 2010. If you have not had any experience with enabling automated testing of BizTalk Server applications, you may benefit from our self-paced online training course covering BizTalk testing strategies.

PipelineTesting Library

The PipelineTesting library is a mature and stable library that has been well maintained and has always remained a step ahead of what was offered out of the box with each version of BizTalk Server. It not only provides a less-clunky API, but a fuller feature set. This is best shown by a short example (although this example does not even get into the depth of what is provided in the PipelineTesting library).

Here is some rough sample code that shows basic usage of the built-in BizTalk Pipeline Testing support:

[TestMethod]
public void TimeReportFFReceivePipeline_TimeReportFF_OutputValidates()
{
    // Built-in BizTalk Pipeline Testing Support
    // (CON: Must be enabled on pipeline project before compilation)

    // CON: Must create the pipeline ahead of time
    TimeReportFFReceivePipeline target = new TimeReportFFReceivePipeline();

    // PRO: Can provide a list of input documents without loading them explicitly
    // CON: Input documents must exist on disk
    StringCollection inputDocuments = new StringCollection();
    inputDocuments.Add(Path.Combine(TestContext.TestDeploymentDir, "TimeReport_3.txt"));

    StringCollection parts = new StringCollection();

    Dictionary schemas = new Dictionary();
    // CON: Must reference .xsd file
    schemas.Add("TestWorkshopApplication.Messaging.TimeReportFF", @"......MessagingTimeReportFF.xsd");

    target.TestPipeline(inputDocuments, parts, schemas);

    // CON: Must locate output messages as files
    DirectoryInfo testDir = new DirectoryInfo(TestContext.TestDeploymentDir);
    FileInfo[] outputList = testDir.GetFiles("*.out");

    Assert.IsTrue((outputList.Length > 0), "No outputs for pipeline found");

    foreach (FileInfo file in outputList)
    {

        /* Additional testing of message content */

    }
}

Now compare that with a code performing roughly the same test using the PipelineTesting library:

[TestMethod]
public void TimeReportFFInPipeline_TimeReportFF_OutputValidates()
{

    // PipelineTesting Library Pipeline Testing Support

    String sourceFile = Path.Combine(TestContext.TestDeploymentDir, "TimeReport_4.txt");

    // PRO: Can compose a pipeline at runtime
    FFDisassembler ffDasm = Disassembler.FlatFile().WithDocumentSpec(typeof(TimeReportFF));
    ReceivePipelineWrapper target = Pipelines.Receive().WithDisassembler(ffDasm);
    target.AddDocSpec(typeof(TimeReportFF));

    MessageCollection result;

    // CON: Have to manually load input document
    // PRO: Input document can exist only in memory
    using (var readStream = File.OpenRead(sourceFile))
    {
        IBaseMessage msg = MessageHelper.CreateFromStream(readStream);
        result = target.Execute(msg);
    }

    Assert.IsTrue(result.Count > 0, "No outputs found from flat file pipeline");

    // PRO: Raw IBaseMessage instances of outputs are available in memory
    foreach (IBaseMessage msg in result)
    {

        /* Additional testing of message content or context */
    }

}

It actually doesn’t take too much effort to get this library working with your BizTalk Server 2010 solutions, and in turn with Team Foundation Server 2010. You will have to upgrade the solution to the Visual Studio 2010 format, and re-reference the PipelineObjects library (exists under the Program FilesMicrosoft Visual Studio 10.0Common7IDEPublicAssemblies folder). If you don’t have NUnit installed, you can exclude the Test project from the build. Once you have it built, you’re good to start writing tests against your BizTalk Server 2010 artifacts. When automating the build and test with Team Foundation Server, you will need to remember to include the .dll somewhere within source control.

BizUnit 3.1

BizUnit is a framework for performing automated integration and functional testing of BizTalk solutions. It takes a black-box approach, and requires that all artifacts are built and deployed before testing commences. If you already perform manual end-to-end testing of your BizTalk applications, you could likely benefit greatly from BizUnit over time. It provides a huge library of pre-built test steps (e.g., start BizTalk host, copy a file, wait for a file, execute a database query) that have the net effect of saving you a lot of time. Test cases, which are combinations of test steps, exist in a declarative XML format that are processed by the BizUnit class which can be invoked from within your MSTest or NUnit test assemblies.

Getting BizUnit working for BizTalk Server 2010 is not necessarily a very easy process. Before you even begin, you must consider that there are two versions currently available. The most recent version is BizUnit 4.0 Beta, which completely changes the test case format (to use XAML), and looks to be the way of the future. However, it does not look like that version has been updated in quite some time, so it is unclear when a final release will be ready. The other version available is BizUnit 3.1, which is stable and has a fully developed library of test steps along with full documentation. For the sake of this blog posting, we will go forward with 3.1, and examine some of the issues you will encounter.

This is another instance in which you will have to upgrade the solution to the Visual Studio 2010 solution file format. From there, you will notice that the solution has a project for each category of test step (e.g., BizTalk steps, LoadGen steps, MQ Series steps, Outlook automation steps, etc…). You can exclude the project for any type of step that you will not be using. Then for each of the “Steps” projects, you will need to re-reference assemblies, so that the latest versions are referenced. You might notice at this point, that the BizTalkSteps project has a dependency on the PipelineTesting library already discussed. You will definitely want to include the version that you built against the BizTalk Server 2010 binaries here. This is another place where you will need to remember to include the .dll’s for both the BizUnit runtime and the steps that you will be using within source control, or simply install BizUnit on each build server if that makes more sense in your environment.

bLogical Custom Tasks

With BizTalk Server 2009, it became possible to automate builds of BizTalk applications without installing Visual Studio on the build server (though it is required to install the Project Build Component from the BizTalk installation media). It was also possible with BizTalk Server 2009 to automate tests and, with the help of community tools, automate integration and functional tests. However it was still not possible, using only out-of-the-box functionality, to include deployment as part of the build. The custom MSBuild Tasks for BizTalk by bLogical were developed to add the missing deployment step to the automated build process. Unfortunately, there are a few issues that still need to be overcome for these to work with Team Foundation Server 2010.

First, the easiest problem to deal with is in the GacHelper.cs class within the project:

namespace Blogical.Shared.Tools.BizTalkBuildTasks.Internal
{
	public class GacHelper
	{
		#region Private Fields
		const string ToolName = "bingacutil.exe";
		#endregion

This path gets concatenated with the path to the .NET Framework SDK to resolve the full path to the gacutil tool. Unfortunately, this will reference the old gacutil tool. For .NET 4 assemblies, the new tool path should be "binNETFX 4.0 Toolsgacutil.exe".

The second hurdle isn’t so easily solved. There is a dependency, mainly in the internal TeamBuildTask base class, on classes within the Microsoft.TeamFoundation.Build.Proxy namespace. This has been obsoleted, and no longer appears in the 2010 version of the assembly. This means that, at least for now, you will now have to provide your own solution for these small missing pieces in the automated build/deployment process. Post a comment if you have found an alternative solution, or keep watching this space for updates on this.

Summary

Using BizTalk Server 2010, you can still benefit from the automated build and testing capabilities released with BizTalk Server 2009, and most of the community solutions developed to enable continuous integration. There are a few steps necessary to get everything working and setup, and a few missing pieces that you will have to build yourself, but the end result is beautiful.

Also, bear in mind that Team Foundation Server is not just about source control and it’s not just about automated build or testing. It’s also about issue tracking, project management, and reporting. If you are paying for a license, make sure that your organization is taking full advantage of it — especially on your BizTalk Server integration solutions. Be sure to check our new collection of instructor-led training on Application Lifecycle Management using Visual Studio 2010 and Team Foundation Server 2010.

BizTalk Server 2010 Released – Developer Edition Now Free

By Nick Hauenstein

Microsoft has just released BizTalk Server 2010, and it is now generally available! Along with this release comes an updated licensing structure that will be a relief for consultants, and companies managing multiple BizTalk environments. While the cost of the Enterprise edition has increased, the cost of the Developer edition has been eliminated. The Developer edition includes the full capabilities of the Enterprise edition, with the limitation being only that you cannot use it in production.

The pricing and licensing page sums this up saying:

Note: Many customers who deploy BizTalk Server implement separate development, testing, and production environments for their BizTalk Server 2010 solution. For the development and testing environments, you can use the free download of the BizTalk Server Developer Edition.

For the production environment, you need a valid processor license of BizTalk Server 2010 Enterprise, Standard, or Branch Edition for each processor on which you install an edition of BizTalk Server 2010.

I applaud this move by Microsoft, as it could encourage a new generation of developers to download and experiment with this powerful platform. This is a move that could drive adoption while at the same time potentially lower the TCO for those organizations managing multiple environments. Given the nature of BizTalk Server, I trust that this will not result in an equivalent of Eternal September for the BizTalk community, but don’t quote me on that remark.

To further help out developers that are new to BizTalk Server in general, we are offering a major discount on our BizTalk Developer Fundamentals online course. Simply use promo code BT2010 when you register, and you will receive $295 off a self-paced registration. This offer expires at the end of September, so act fast!

Finally, go and get BizTalk Server 2010 while it’s still cached at a CDN server near you!

Are You Ready for BizTalk 2010?

By Nick Hauenstein

The next major release of BizTalk Server is just around the corner. Microsoft has had some of the new features brewing since before BizTalk Server 2009. Others have been long sought after functionality that have yielded many third party components to fill the gap. In an industry where change is always on the horizon the one thing that remains constant is the question of readiness. Are you prepared for the launch of BizTalk Server 2010?

Let’s drill into some of the new features to find out what it can provide your organization.

Enhanced BizTalk Mapper

imageOne of the features, that will stand out the most as you open up Visual Studio 2010 to create your first new BizTalk Server 2010 project, is the new and improved BizTalk Mapper. New features include:

  • Ability to search a map for a given schema node, or functoid
  • Ability to cut, copy, and paste functoids and links between maps and pages
  • Cleaner display of map links based on how related they are to schema nodes within the view
  • Automatic highlighting of links and functoids related to the active selection
  • Automatic scrolling into view of links and functoids related to the active selection
  • Simplified configuration UI for functoids (e.g., the scripting functoid has a single tabbed window with which you can fully configure the connections and the script)
  • Indicative match functionality that suggests nodes to link

These features and others make dealing with large maps, re-using existing maps, and creating new maps a much more pain free experience. Many of the features the new BizTalk Mapper offers derive from a version of the BizTalk Mapper demoed at PDC in years past – they have more than delivered on what was already demonstrated.

Updated Trading Partner Management (TPM) Capabilities

imageAnother fairly major change within BizTalk Server 2010 is the way in which Parties are configured. Previously, if you had a party with whom you interacted with in multiple ways, there was not a clear way to configure and logically categorize those interactions within the Admin console. BizTalk Server 2010 solves this problem by bringing in the concepts of Business Profiles, and Trading Partner Agreements.

A Business Profile is a singular role that a trading partner could play, or a singular instance of that partner. For example you could have a trading partner that at sometimes will be a vendor, and at other times will be purchasing from your business. Those two roles would become two separate Business Profiles attached to the same party. You could also have a trading partner that has both a US and European division, those could also become separate profiles. Each profile also has related identity and protocol settings that can be configured.

A Trading Partner Agreement is a definition of how two profiles interact, including the selected protocol settings for each side of the communication.

Managing parties in this way still enables rapid change, but also allows for logical organization and consistency for those partners who interact in multiple ways with your enterprise.

Adapter & Integration Changes

Since BizTalk Server 2009, and even somewhat earlier, we have seen BizTalk adapters in a slow but steady migration over to WCF counterparts. BizTalk Server 2010 continues in this path as the SQL adapter finally rests in peace. The WCF-SQL adapter serves as its replacement (alternatively WCF-Custom using the sqlBinding binding).

In a similar turn of events, the SOAP adapter has also been deprecated in this release, and with it the BizTalk Web Services Publishing Wizard.

This slow migration to WCF-based adapters has not stopped the product team from making key updates to existing adapters however. The FTP adapter has been updated to support both FTPS (not yet SFTP), and read-only FTP locations. This functionality has been long sought after, and a few third party components had been filling this gap. That will no longer be necessary.

 

BizTalk Server Settings Dashboard

imageThis new feature is not quite as glamorous as some of the others, but is still a huge improvement. The BizTalk Server Settings Dashboard is a new UI for configuring the key performance, throttling, and tracking settings of your entire BizTalk group while offering fine grained control all the way down to the Host Instance level. It combines settings that had previously been strewn about in the Admin Console, the registry, the BizTalk configuration file, and the configuration database, into a single logically organized UI.

Further, it allows you to import/export these settings for transfer between environments (even when the naming of the hosts and host instances does not match the original environment. This is going to be a boon for controlled performance testing, and something to keep in your back pocket.

Updated Platform Support

This release of BizTalk Server will no longer be supported on Windows Server 2003. Instead the minimum requirement will be raised to Windows Server 2008 with SP2, and it will also support running on Windows Server 2008 R2. If you’re running it for development purposes, it will also support both Windows Vista with SP2 and Windows 7 on the desktop OS side of things.

For development you will now be using Visual Studio 2010 when dealing with BizTalk Server. Visual Studio is, by far, Microsoft’s best IDE to date. I was personally hesitant at first given its whimsical color scheme, however shallow that may be, but the productivity gains ultimately sold me – that, and the fact that it even runs perfectly happily on my netbook.

If you’re not running SQL Server 2008 yet in your environment, you will be. BizTalk Server 2010 supports both SQL Server 2008 SP1, and SQL Server 2008 R2.

How to Obtain BizTalk Server 2010

If you want to start diving into BizTalk Server 2010 now, you can find the link to download the Beta at Microsoft’s BizTalk Landing Page.

QuickLearn also offers a class on BizTalk Server 2010 aimed at developers who would like to update their skills to Microsoft’s latest offering. A preview of that class, and our new self-paced learning environment, can be accessed through the link on the QuickLearn Online Anytime page.