BizTalk Server has been around for quite a long time, evolving over the years and becoming one of the most complete and powerful middleware products in the market, helping thousands of companies to fulfill their requirements in terms of Systems Integration.
With such a powerful product and the flexibility it provides to implement integration solutions, it's more than useful to have at hand a set of architectural patterns and re-usable components. These will support our design and help us to reach the most successful result possible. And here's where the ESB Toolkit comes into the picture.
In this chapter, we will have an overview of:
What is Enterprise Service Bus (ESB)
What are the architectural principles that define an ESB
How the ESB Toolkit helps to build better integration solutions
What are the ESB Toolkit features and components
The content within this book is not meant to be a long dissertation about the different architectural terms and acronyms coined over time that lead into the definition of what an ESB is about. We will save you some time by going straight to the point of defining the basics of ESB so you can spend that extra time on enjoying a good BBQ.
An Enterprise Service Bus (ESB) is an architectural model that defines the patterns to integrate IT systems by interconnecting an ecosystem of loosely coupled and interoperable business services and components in an elastic way. The ultimate goal is to provide a flexible implementation of the enterprise business processes in such a flexible way that those processes can be efficiently adapted to the ever-changing circumstances of the enterprise.
In the following figure, we can see different example business processes that could be run within our ESB, as a set of decoupled business services or stages:
In most cases, a business process is all about how information travels through the process and how it is handled along the way, and thus the ESB model predicates the integration of such business processes in terms of the five basic steps that conform to the VETRO pattern:
Validate: This is usually the very first step of the information processing, where we ensure that the information received is in the format expected, although there can be other validation steps along the process. This validation against the mutually agreed service/data contracts ensures that the information flowing through the ESB is legitimate and compliant with the expectations of any system connected to the bus.
Enrich: During this step, the information is enriched so it contains all the data required to continue its journey and provide a meaningful input to the target system.
Transform: The information is transformed to the format the target system expects and understands. This step could happen as the information arrives at the ESB (where in this case the target system is the ESB itself) where the information would be transformed into a canonical format (quite often defined by the company's Enterprise Data Model), as well as when the information leaves the ESB, transforming it from the canonical format to the format expected by the target system.
Route: In systems integration, the information intrinsically has to travel from one place to the other, and that is what happens during this stage. The next step the information needs to take is identified and the route is applied so the process can continue as expected.
Operate: The business processes are all about triggering actions within the enterprise that achieve the mission the process is designed for. In this stage, the target system is delivered the input information so any required actions are taken and any expected outcomes are produced. In essence, the Operate step is the invocation of a target service or even an interaction with the target service.
The ESB receives messages from the systems connected to it and performs one or more of the steps mentioned previously. All those steps that define how a message needs to be handled by the ESB are defined as itineraries, that are a set of decoupled processing steps that doesn't necessarily know about the whole process the message just went through or is going to go through afterwards, but they just know what they have to do with the message they just received for processing.
This doesn't sound like rocket science or anything very new, but what the ESB adds to the pattern is the means to make all these stages along the process as decoupled and configurable as possible, so once a process is in place any further changes can be made with the smaller effort and the smallest impact possible on existing systems.
An ESB has different features and capabilities that support one or many of the elements of the VETRO pattern.
The main capabilities that support this model in the ESB are listed in the following table:
If you have been working with BizTalk Server for some time or have some basic knowledge about its architecture and features, you will find that most of those cover these capabilities any ESB system is required to have, but you will also appreciate that some of them could be implemented in different ways, requiring some extra effort from your architecture team to decide the best way of doing so.
Here is where the ESB Toolkit comes to help. Based on the years of experience of architects and IT teams building integrations solutions with BizTalk, these patterns and capabilities have been packaged as a set of guidelines and re-usable components that will help you to build an ESB solution with a more predictable and efficient result.
In this section, we will get to know what the ESB Toolkit is all about, why it was created, and the benefits it brings to any BizTalk solution, especially to build ESB architectures.
As we saw in the previous section, ESB is an architectural model that can bring huge benefits to the integration architecture of a company, but there would be potentially many ways to achieve the same goal.
Around 2007, a group of talented architects and developers from the Microsoft BizTalk product group and the Patterns and Practices team came up with the idea of the ESB Guidance, as a set of architectural guidelines and re-usable components that would help us to build an ESB based in Microsoft BizTalk Server 2006 R2. This ESB Guidance was renamed later on to ESB Toolkit with its 2.0 version along with BizTalk 2009. The latest versions of it are the 2.1 that came with BizTalk 2010 (the one that we will cover in this book) and the latest one (2.2) that comes with BizTalk 2013.
Note
The main difference between ESB Toolkit 2.1 and 2.2 versions is that the ESB Toolkit 2.2 can be installed directly from the BizTalk installer splash screen, but the rest remain the same, so the contents described in this book apply to both versions.
Most of the current technologies and IT development platforms nowadays provide huge flexibility and power in terms of implementing solutions, but that flexibility and power sometimes make it difficult to know the better way to implement some common patterns.
In the old days of .NET, we all needed to implement common patterns such as aspect oriented programming, error handling libraries, logging, and so on, and there were teams around the world implementing the same things on and on, each of them on their own flavor. But then the Enterprise Library came along to make our life a bit easier.
The ESB Toolkit is to BizTalk the same as the Enterprise Library is to any .NET application. It just helps to implement common architectural and development practices in a reliable and proven way. Whether you are building an ESB or not, some of the ESB Toolkit principles and re-usable components will be really useful to build high quality BizTalk solutions.
The aim of the ESB Toolkit is to cover all of the capabilities required by a proper ESB by leveraging existing features in BizTalk Server, introducing new re-usable components and documenting it all together so we don't get lost along the way.
We can map the main ESB capabilities we listed in previous sections to the BizTalk and ESB Toolkit features like:
|
ESB Capability |
Mapping to BizTalk and ESB Toolkit |
|---|---|
|
Message Routing |
BizTalk content-based routing and ESB Toolkit itineraries |
|
Connectivity |
BizTalk Adapters and ESB Toolkit ramps |
|
Exchange Patterns |
BizTalk Adapters and existing architecture |
|
Transformation |
BizTalk maps and ESB Toolkit components |
|
Service Directory |
BizTalk UDDI Services and ESB Toolkit itineraries |
|
Rules Dynamic Resolution |
BizTalk Business Rules and ESB Toolkit dynamic resolution |
|
Validation |
BizTalk Schemas and ESB Toolkit components |
|
Aggregation |
BizTalk orchestrations and ESB Toolkit itineraries |
|
Service Orchestration |
BizTalk orchestrations and ESB Toolkit itineraries |
|
Assured Delivery |
BizTalk Adapters and ESB Toolkit Exception Handling |
|
Management and Governance |
BizTalk management console, ESB Toolkit management portal, and Business Activity Monitoring (BAM) |
|
Security |
BizTalk Security and SSO |
As we mentioned earlier, all these capabilities are pretty much required to build a full-blown ESB architecture and they should be interoperable and decoupled enough to provide the flexibility and scalability that we need.
All this can be very well represented with the representation of the ESB Toolkit architecture and main components shown in the following figure.
The itinerary is one of the core concepts on the implementation of an ESB solution. It's the definition of the flow of certain piece of information or message must follow, through the ESB to fulfill one specific business process or interface.
The itinerary is composed of a set of steps or processing units that pretty much can be mapped to one or more of the stages defined by the VETRO pattern. Those steps or processing units are called Itinerary Services. They can be either the standard itinerary service components that come with the ESB Toolkit (the Transformation and Routing Services) or our own custom developed itinerary services.
We will get to know the itineraries more in detail in the next chapter of this book.
The ramps are the connection points where the systems can connect to send messages to the ESB and receive messages from it. Those are respectively the On-Ramps and the Off-Ramps and are implemented as WCF web services and BizTalk send ports, although we could build our own ramps based on other types of BizTalk adapters.
The ESB Toolkit also provides a set of web services that expose the functionality of some ESB features to any external systems. Those services are:
Itinerary processing
Exception management
Endpoints and maps resolution
Messages transformation
BizTalk Server operations
BAM services
UDDI services
We will cover these in detail in Chapter 2, Itinerary Services and Chapter 4, Understanding the ESB Web Services.
The services directory is provided in BizTalk and the ESB Toolkit by means of the Universal Description, Discovery, and Integration (UDDI) services. These services provide a centralized registry of the services available across an organization, either for internal or external consumers, exposing all of the required information to categorize, organize, discover, and manage those services' definitions.
We will talk more about it in Chapter 4, Understanding the ESB Web Services.
Exception Management framework is a set of components and APIs that provide a standardized approach to handle, notify, and process any exceptional situations that might occur during the processing of a message. It's pretty much like the counterpart of the exception handling in the Enterprise Library.
We will dedicate a whole chapter to this topic later on in this book.
The ESB Toolkit includes a web portal built on ASP.NET that provides:
Insight to the status of our ESB processes' health with detailed reporting of any issues that might have happened in any of our ESB applications (with a basic implementation of failed messages reprocessing)
Alerting features to create notifications for the ESB administrators of any errors that might happen
Features to manage the new services registry requests users can create
Different management consoles to configure certain features of the system
We will get into the details of the portal on the last chapter of the book.
There are many other re-usable components and tools within the ESB Toolkit that are really helpful during the design, development, and operation of our ESB, as well as components that could be easily re-used in other non-ESB implementations, such as certain pipeline components and libraries. One example of those are the Add/Remove Namespace pipeline components.
Those could come in handy in many BizTalk solutions where we need to deal with systems that are not that careful with how they set the namespaces on the messages submitted to BizTalk. We can use them to:
Add a namespace when the incoming message doesn't have a root namespace
Replace the incoming root namespace when the difference between the external system schema and our canonical schemas just differ in their namespace (so we could avoid the implementation and execution of a ridiculously simple map)
When the type of the inbound message is defined by some data included within the message itself
In this chapter, we have learned about the main architectural principles that define an Enterprise Service Bus, why the ESB Toolkit was something very much needed to help us to build high quality BizTalk solutions, and what are the main features of the ESB Toolkit.
In the next chapter, we will deep dive on the itineraries concept and how it rules the processing of messages within our ESB.