Joel's SharePoint Architect Blog

SharePoint 2010, MOSS & WSS Tips and Consultancy Tales

Subscribe Subscribe  View Joel Jeffery's profile on LinkedIn
joelblogs.co.uk | joelj.co.uk | joeljeffery.co.uk | jfdiphoenix.co.uk

Posts Tagged ‘TechEd 2007’

Extending the IIS 7 Pipeline – Carlos Aguilar Mares

Tue, 13 Nov 2007 22:05:36 GMT

Carlos Aguilar Mares
Senior Development Lead

It seems the architecture of IIS has changed substantially with this release. If IIS6 was the bedrock that got us to Application Pools, and good .NET integration, IIS7 takes us to a new level. The IIS team has done a lot of refactoring to get there.

 

IIS6

IIS7

Monolithic server implementation

Componentised Server

Limited customisation

Pluggable modular functionality

Fixed functionality

Small generic request pipeline

Extensibility limited to ISAPI Filters

Enables lightweight servers and specialised servers

 

In IIS6, ASP.NET is implemented as an ISAPI filter, which sits right at the end of the pipeline. This caused a few problems – including duplication of features and wasted computation; authentication in ASP.NET would happen after IIS6 authenticated anyway. Another example of authentication badness in IIS6 occurs when you try to secure non-ASP.NET assets: you can only accomplish this by funnelling all HTTP requests via ASP.NET.

IIS7 offers two integrations models: Classic Mode (for compatibility – like IIS6) and Integrated Mode. ASP.NET is now implemented as a bundle of modules that fit into the redesigned IIS pipeline. Integrated Mode can process *all* requests and gives hider fidelity notifications.

.NET Extensibility

  • Existing ASP.NET API – using IHttpModel and IHttpHandler types
  • Expanded ASP.NET APIs
    • New HttpApplication Events
      • MapRequestHandler, LogRequest, PostLogRequest
    • Inject and modify IIS system headers and collections
      • HttpRequest.Headers
      • HttpReponse.Headers
      • HttpReponse.DisableKernelCache
      • HttpReponse.ServerVariables

Handlers vs Modules

 

Modules

Handlers

Provide services to all requests

Provides services to specific extensions

Basic Authentication module

Handlers ISAPI handler (.dll)

Compression module (etc)

Static handler (.htm, .jpg, .gif,  etc)

 

IIS 7 pipeline allows native and managed modules and handlers

  • “Integrated” Application Pool mode
    • use the managed modules and handlers
    • ASP.NET v2.0 and above can be configured to run in Integrated Mode
  • “Classic” Application Pool
    • IIS 6 style invocation of .NET
    • ASP.NET v1.1 and earlier can only be configured to run in Classic Mode

Building Managed Modules and Handlers

Modules – Building a Module to cause IIS to Log to SQL Server

The steps to build a module are more or less:

  • Add a class to your project – e.g.  public class SqlLogModule: IHttpModule
  • Edit the code!
    • Add to public void Init()
      context.LodgRequest += new EventHandler(OnLogRequest)
    • Fill in OnLogRequest
      HttpApplication app = (HttpApplication) sender;
      Log(app.Context); // TODO: write this function! :)
  • IIS Manager -> Configure Modules -> Managed Modules
    • Add Managed Module
      • Name "SqlLogModule"
      • Type "SqlLogModule"
        This adds web.config to our project!
  • Edit web.config <system.webServer> section. ASP.NET ignores this section; it’s only read by IIS7.

[Side question: how is all this possible? Won't ASP.NET 2.0 keel over at this point? Answer: no, .NET v2.0 was refactored for Vista and Server 2008.] 

Technorati Tags: ASP.NET, IIS Pipeline, TechEd 2007

Tue, 13 Nov 2007 16:52:19 GMT

Jaser Elmorsy

CEO BlueBridge Technologies

 

This promised to be an interesting session. It’s always good to see how the non-Microsoft presenters do.  Jaser is a Microsoft Regional Director, and the CEO of a software firm based in Vienna.

 

Scrum  101

The session started with an overview of the SCRUM methodology. Covering

  • Product Backlog
  • Sprint Backlog
  • Daily Scrum Meeting
  • Potentially Shippable Product Increment

 

Jaser goes on to define the roles in Scrum:

  • Product Owner

The Product Owner is the customer, and can be internal or external; has rights and responsibility.

  • Scrum Master

Represents management to the project, and is responsible for enacting Scrum values and practices. The Scrum Master’s main job is to remove impediments.

  • Team Members
  • Stakeholders
  • Users

 

A typical team should look like:

  • 5-10 Members
  • Cross-functional – QA, Programmers, UI Designers
  • Members should be full time
  • Teams are self-organising

 

Scrum for Team Foundation Server

There are three main plug ins for VSTS.

  • Scrum for Team System
    • Pros
      • Process guidance and free training videos are available.
      • Mature, with several updates
      • All sprint artefacts present
      • Good reports including portal reports
      • Widely adopted, support through forums
      • Includes tool to update warehouse
    • Cons
      • Reports have a lot of custom code
      • No integration into Areas and Iterations
      • Only one active project per Team Project
  • Microsoft eScrum
    • Pros
      • Very good web portal for managing sprints and sprint artefacts
      • Context-sensitive help in web portal
      • Dynamic capacity calculations in portal
      • All sprint artefacts present
      • Ability to have multiple Products in one Team Project
      • Allows definitions of each role
      • Integrates with Areas and Iterations
    • Cons
      • Quite new (v1.0 release in July)
      • Setup needs improvement
      • Not as many reports
  • VSTS Scrum Process Template
    • Pros
      • Lightweight, good integration into Areas and Iterations
      • Good list of reports
      • Supports basic Scrum / Agile work items
      • Custom works item for reviews
      • Open source – frequent updates
    • Cons
      • Open source – hard to get support
      • Not a lot of people using it
      • No installer

 

Editing the Process Templates in Visual Studio 2008

The cool part of Jaser’s presentation is demonstrating the editability of the process templates to make one of the available Scrum templates look a bit more like real Scrum.

 

By opening the WorkItemTracking/TypeItemDefinitions/ProductBacklogItem.xml in Visual Studio, he could  edit the "Estimated Effort" field and give it some sensible units (hours). Additionally, he was able to remove the "owned by" field (as backlog items aren’t assigned to individuals in his implementation of Scrum). After editing the xml file, you need to upload the definition into VSTS using the Process Template Manager. All *new* projects based on this template will take on the new process changes – existing projects will not.

 

Adding Fields

Using the designer in Visual Studio, you can add extra fields  (or questions) to various forms that make up the process template. The demo showed editing fields of the Daily Scrum Meeting to something more usual. Each field you add you can define how t is to be used in reports, by marking "Reportability" as "detail, " "dimension," or "measure." Dimension and measure result in the field getting copied into the VSTS OLAP cube; detail fields are simply kept in the relational database.

 

The designer lets you specify on-screen field types, such as date time pickers, textboxes etc.

 

First Thoughts

The designer – the Process Template Editor – is an interesting thing. It’s not drag and drop, Visual Studio style. It’s very declarative. The designer uses property grids to edit the form and field metadata, but it still feels clunky. It leaves me wondering if this is so that forms can be rendered in different environments – inside the IDE, inside a browser…

 

State Machine

VSTS comes with a mandatory state machine for work items. The Process Template Editor forces you to add at least one field that has state. You can edit the state machine using the graphical tools to show progression from one state to the next.

 

Getting Closer to Useful

This gets us a little closer to a position where the product set becomes useful. The problem for me is in comparison to our Scrum implementation, this seems long winded. Our backlogs live in Excel. Row-based, and familiar. VSTS plugins seem to turn this into a record-by-record affair, with a CRUD screen to capture your backlog work item data.

 

Scrum Reporting using SQL Server Reporting Services

Jaser showed how to build a simple report using SQL Reporting Services in VS 2005. The .rdl report file is simply copied to the Process Template folder. The sample report showed the fields Jaser added to his custom form.

 

Web Portal for Scrum in VSTS

VSTS gives you a portal per project. As part of the demo, they created a web part in VS 2008 showing "update warehouse" functionality. The portal lives in Windows
Sharepoint Services 3.0. This web part then forces the OLAP cube to update, and consequently the burndown chart gets updated. BlueBridge is releasing these parts to the community.

 

Burndown Analysis

Next Jaser walked us through programmatically analysing the produced burndown chart. All the data for the chart is held in the OLAP cube, with the detail held in the relational store.

Jaser wrote a stored procedure in the TFS warehouse database to predict bugs using the built in SQL Server weighted average function.

 

Jaser’s algorithm is:

  • Sum estimated remaining effort
  • Calculate ideal ratio of burndown using the weighted average function
  • Calculate how much estimated effort should be burnt per day to hit the ratio
  • Compare ideal ratio with the estimated ratio; if the difference is too great, this means the burndown chart shows a too favourable estimate of completion.

"Too great" is a threshold value – by default they set this to 20 hours for the team size, but this is tunable.

 

This is also implemented in SQL Analysis Services. BlueBridge have a bunch of other Scrum analysis projects which will be released over the course of December, but the link is not yet available.

 

Technorati Profile

Technorati Tags: SCRUM, TechEd 2007, VSTS

Tue, 13 Nov 2007 13:06:11 GMT

An excellent session. It did degenerate after a while into an architectural naval-contemplation session, but Shy did come up with one of the most succinct expressions of the Autonomy tenet of services:

"Don’t confuse autonomy with independence. Services are autonomous, but not necessarily independent. It’s like countries. They are politically autonomous entities, but they depend upon other countries to exist. It’s why we have import and export."

 

A Framework for Taxonomy

 

Shy proposes a framework to help us organise services across an enterprise.

 

clip_image001

 

Bus Services

Two different kinds of services – shown in orange above, Bus Services are part of the supporting distributed computing infrastructure and not specific to any application.

Utility Services

  • Offer message transfer facilities
  • Message routing, publish subscribe, etc

Communication Services

  • Offer services unrelated to message transfer
  • Service discovery, federated security, etc

 

clip_image002

 

Application Services

These are coarse-grained, high-level application building blocks,:

  • Entity Services – Manipulate business services; e.g. Employee, Purchase Order, Conveyer Belt
  • Capability Services and Activity Services – Functional building blocks of the application, Verify Customer Credit
  • Process Services – Compose and orchestrate Entity, Capability and Activity Services to implement business processes – e.g.  Authorise Holiday, Process PO.

 

clip_image003

 

In Detail – Bus Services – Communication Services

Role

  • Transport messages in, out, within the system; across network or protocol boundaries
  • Not Concerned with the content of the messages; schema agnostic; may use message parts to determine message advancement

Interfaces

  • Generic for receiving and forwarding messages (interface is message-schema agnostic
  • Management and monitoring interfaces

 

Characteristic

Details

State Management

No app state. Self state configured by the applications

Monitoring and Diagnostics

Analysis of message traffic patters. Error rate reporting

Security

App-specific requirements, regulatory etc, with permissions at App, Use or App-User

Errors

Network level, e.g. Round-robin

Construction and Management

A commodity (build centrally or buy) that’s built to last and is centrally managed

 

In Detail – Bus Services – Utility Services

Role

  • Shared Infrastructure – not message transport
  • Generic, non-messaging, app-agnostic services
    • e.g. STS, discovery, message schema translation
  • Configured on how to perform operations for the app
    • e.g. Schema mapping for schema translation service

Interfaces

  • An interface specific to the services functionality
    • Process messages sent to it
    • Message exchange is typically request-response
  • May also have management and monitoring interfaces

 

Characteristic

Details

State Management

No app state. Self state configured by the application

Monitoring and Diagnostics

Analysis of service requests. Error rate reporting.

Security

App-specific requirements, regulatory etc. With permissions at App, User or App-User

Errors

Errors handling is specific to the service’s functionality

Construction and Management

A commodity (build centrally or buy) that’s built to last is centrally managed

 

In Detail – Application Services – Entity Services

Role

  • To unlock and expose the business entities of the system
    • Data-centric components ("nouns") of the business process
    • Expose the information stored in one or more data stores in the system through a service interface
  • Abstract data stores
    • e.g. SQL Server, Active Directory, etc
  • The information being managed is of general interest
    • Used in several or even all the systems in the organisation

Interfaces

  • CRUD interface at the entity level
    • Operations may depend on access and modification restrictions
    • Entities are structured types
    • Underlying data stores typically relational or hierarchical
  • Additional domain-specific operations
    • Addressing problem-domain
    • Support app’s features and use-cases
      • e.g. FindCustomerIdByPhone
  • Functional Interface; i.e. CRUD + domain specific functionality

 

Characteristic

Details

State Management

Manage the persistent state of the system, typically for longer than any single process.

Consistency

Atomic transaction and reservation pattern

Security

App-specific access restriction requirements, regulatory etc. Permission at App/User levels

Errors

Seeking alternative data sources,. Error policy part of SLE/SLA

Construction and Management

Built in-house to last (SW factory, DB feature). Used by multiple apps across the enterprise.

 

In Detail – Application Services – Capability Services

Role

  • Represent business-level capabilities of the organisation
  • Action-centric building blocks of the organisation’s business processes
    • "Atomic verbs"

Interface

  • Interface specific to the capability they represent
  • May thinly wrap an existing legacy) or newly acquired business capability
    • Facade service is opaque
    • Underlying capability can be replaced without changing the service interface use to access it
    • Facade service is considered the Capability Service

 

< td style="border-right:#a3a3a3 1pt solid;padding-right:4pt;border-top:#a3a3a3 1pt solid;padding-left:4pt;padding-bottom:4pt;vertical-align:top;border-left:#a3a3a3 1pt solid;width:1.772in;padding-top:4pt;border-bottom:#a3a3a3 1pt solid">

Security

Characteristic

Details

State Management

Manage transient state, for shorter than the duration of the process

Consistency

Atomic transaction (flowed downstream) and Reservation pattern (over downstream store)

App-specific access restriction requirements, regulatory etc. Permission at the App level.

Errors

Error compensation part of SLE/SLA

Construction and Management

Built / Buy / Lease to last (workflow or code). Managed centrally.

 

In Detail – Application Services  - Activity Services

Role

  • Business level capabilities or action centric business logic elements ("building blocks")
    • Used in a single composite app or a single solution
    • May evolve into Capability Services
  • Forces impacting creation of Activity Services
    • Decomposition of a complex process
    • Enabling reuse of functionality in several places; within a single process service or across multiple process services
    • Pressures can come from architecture/implementation requirements, organisation forces within the business, security requirements, regulatory requirements etc.

 

Interfaces

  • Service interface is specific to the capability
  • Possible for Activity Services to wrap existing units of functionality

 

Characteristic

Details

State Management

Manage transient state, wrapping cases will actually hold app state

Consistency

Atomic transactions used internally; Reservation pattern externally

Security

App-specific access restriction requirements, regulatory etc. Permission at the App level.

Errors

Error compensation part of SLE/SLA

Construction and Management

Built in house to last. Used by single apps and managed as such. Over time, may become a Capability Service

 

In Detail – Application Services – Process Services

Role

  • Combine data-centric and action-centric building blocks to implement business processes
    • Compose the functionality of Activity Services, Capability Services and Entity Services; tied together with business logic.
    • Designed to enable process agility
  • May be composed into the workflows of other Process Services
    • Because of their long running nature, they are not categorised as Capability or Activity Services; also they implement an agile process.

 

Interfaces

  • Often fronted with a UI that initiates, controls and monitors the process
    • Service interface typically geared towards consumption by presentation tier
    • Level of granularity designed for user-facing, front-end applications
  • Monitoring the business process (BAM)

 

Characteristic

Details

State Management

Manage app state for the duration of the process

Consistency

None, or reservation pattern if recomposing

Security

User specific access restriction

Errors

Error handling is an integral part of the process being implemented

Construction and Management

Built in house to change (e.g. Workflow). Typically used by a single app and managed per application. May be recomposed into another process.

 

Summary

 

The taxonomy provided here just gives very high level holding places for your services. The important part here is that we all start using the same names for things. When we have a large number of services, we will find this taxonomy does not provide a suitable level of granularity and distinction between them.

 

One way round this would be to devise a lower level taxonomy orthogonal to this one, as and when we need the extra flexibility to our vocabulary. So, you may decide to add a level of granularity based on business functionality. For instance, Customer Activity Services, or Purchase Order Process Services.

 

Technorati Profile

Technorati Tags: SOA, TechEd 2007, Web Services

Mon, 12 Nov 2007 18:22:35 GMT

It’s been a while since I last saw Pat presenting on SOA. He hasn’t lost the magic. But he has lost a ton of weight. Or gained a lot of height or something! Pat – well done mate!

Continuing his Metropolis series of SOA talks, Pat’s theme this time is around composability and interchangeability of Services.

A Short History Lesson

The European System of Manufacturing – before 1800s

The build of complicated objects required each part to be manually lathed or turned in such a way that no two craftsmen produced the same precise part; no two (otherwise identical) parts produced by the same craftsmen were identical enough to be interchanged. To scale up, more craftsmen were required. When things broke down with the goods being built, replacement parts would require "manual fitting" to make them work. Variance in the manufacture of parts caused unscalable systems.

The American System of Manufacturing – circa 1800s

Due to a lack of manual labour and engineers, the Americans adopted a mechanised approach of manufacture. Heavy (steam) power tooling was used, which saved labour. However, these were not automated, and variation in parts produced during manufacture was inevitable. Manual fitting was still required; machinery just got us to that point quicker.

The US Armoury System of Manufacturing – mid 1800s

Le Blanc, Jefferson, Whitney hypothesised a system of interchangeable parts, which depended upon the manufacture of specific parts being reproducible, predictable, and with tight tolerances to variation. Notably, Whitney won a contract with the US military to manufacture arms using this method; he failed because he was unable to eliminate the requirement for manual fitting – i.e. the methods were too hard to produce identical, interchangeable parts to their rifles.

John H. Hall, circa 1820s

John H. Hall developed accurate machines to build interchangeable parts in gun manufacture. His machines were expensively hand crafted to accurately reproduce, time and again, the same parts down to a very fine tolerance in variation. Ultimately Hall was to fail as he lacked the funds to realise economies of scale.

Sewing Machines – circa 1870s

Wheeler and Wheeler sewing machines produced 25,000 machines in 1860. By 1876 this figure rose to 108,000. They achieved this by using machines to make their products. Brown and Sharp also adopted this method.

The Pope Bicycle – circa 1890

Parts built by Sharps Rifle Company using machines that worked from reusable, accurate templates.

Why is this important?

This takes the narrative from European, hand-finished manufacture, all the way through to the Model T Ford, via the US Armoury and the Pope bicycle.

Model T Ford

Ford was inspired by mass production of meat. Butchers – working in what Pat calls "disassembly plants" – would stand in front of a conveyor of meat carcasses, and apply the meat cleaver to each one without having to move from carcass to carcass. What impressed Ford was the efficiency with which the production line operated. The "operator" never had to move; the parts were brought to the operator. From this, it’s a relatively short journey to Ford’s Assembly Line of Model Ts.

The Assembly Line’s purpose was to eliminate custom fitting altogether. From this he derived the ability to repeatedly, repeatably, indefinitely minimise variation and produce tens of thousands of identical parts. Ford’s machines and buildings were tailor made to the design of a specific car. To change the design required buildings to be dramatically changed, and machines to be retooled. For 20 years the Model T Ford did not change at all in design. A new one was virtually indistinguishable from one 10 years its senior.

General Motors

GM introduced the concept of the recurring annual new model. Arguably the first concrete example of agile manufacturing. GM provided heavy duty, multi-puropse, multi-site production processes and equipment, taking the assembly line approach from Ford and extending to allow reuse of key components – engine, chassis, transmission, etc – whilst allowing evolution of other components – e.g. bodywork, gearing.

This first example of flexible mass production owes everything to mechanised production and complete interchangeability of parts. This allowed GM to rapidly (over a number of years) change to new models.

From History to Transactions

American System of Transaction Processing

Pat then draws the comparison between early American manufacture to traditional transactional processing.

Any two appilcations performing similar tasks are allowed by the technology an immense amount of flexibility and variance in implementation. Consider the operation to update an accounting and an invoicing system. This could be implemented in a massive variety of different ways; at the simplest level, updating accounting tables first, and invoicing tables last. Alternatively the other way round is equally logical.

It is precisely this flexibility of the toolset – in the case of manufacture we’re talking about lathes, planes and so on; in the case of transactions we’re talking about software languages, programming environments, etc – which gives the problem. Of course, this is only a problem when you come to a point that you need to swap out the accounting or invoicing system for a new one.

So – flexiblity of this scale is a problem when we cross boundaries of trust or service. Instead, we should try and aim for a more appropriate model of…

Transactional Machine Tools

Applying the General Motors model to application development, we need to consider:

  • Applications are Independent, Standalone – although no program is an island, eh Don?
  • Interconnectivity with Independent Services – services share Schema (format), Contract (sequence) and VERSIONED Reference Data.
  • Optimistic Concurrency does not stretch across Trust Boundaries – Interactions should be based on business functionality, not data exchanges!

That last point is particularly poignent. Consider, if you will, Optimistic Concurrency and your bank. You can’t just give your bank a set of new values you’d like your balance to be. You have to invoke business operations; Deposit, Withdraw. Incidentally, banks do not do atomic transactions as such. Deposit and Withdraw are examples of potentially long running, cancellable transactions; which brings us to….

Armoury System of Transactions

We can go one better right now. If the US Armoury had been building transactional systems, they would have probably built them to use:

  • Compensating Operations
  • Tentative Operations
  • No Transactions Shared Across Boundaries

Pat then quoted one of his previous discourses. "Two phase commit is the anti-availability protocol." Which makes a lot of sense. 2 Phase Commit locks resources; the more contention, the worse the locking. For services, that should be composable, this is not acceptable.

Key to deriving the same economies of scale with services are Tentative Operations (Cancellability), Composability and Nesting of Cancellation. At all costs, avoid Variance, Option and Choice. These are bad for interchangeability.

A Word about Data

Consider two kinds of data – Activity Data and Resource Data. These data have very different requirements during transactional handling.

Activity data, is what you might find in activity-related operations. Your Amazon shopping basket; deposits to your bank balance. These are things t
hat can be rolled back very easily if anything should go awry. Compensating actions are easy to devise and apply.

Resource data is altogether more complex. Consider booking hotel rooms for your stay during Tech Ed. If the conference were cancelled before the event, each night of your potential stay would have to be compensated. The night of Nov 5th. The night of Nov 6th etc. All get one extra spare hotel room added back to the appropriate bucket. Back to the "Reservation Pool" if you will.

Essential in the handling of resource data – in Reservation Pool Management – is that all access and changes should be contained within, encapsulated in, a suitable Reservation business operation.

To handle these various scenarios, your operations need to be able to cope with

  • Long Running Transactions
  • The Ability to Place the Same Order Again
  • Tentative Operations

In order to achieve these behaviours, remember: Specificity GOOD, Variety BAD.

Domain Specific Languages

DSLs are the heavy duty, multi-purpose machine tools of the General Motors model. Just as GM was able to swap out chassis, transmission, engine parts, DSLs let you swap out logon services, retrieve customer services, accounting services.

DSLs get us close to flexible mass production. Harping back to the World of Warcraft in Visual Studio demo of the Keynote – wasn’t that an example of a Domain Specific Language that churned out Lua code? Retooling made easy, without having to restructure your factory (your IDE) or your craftsmen (your dev team).

Finish on  a Song

OK. He didn’t. Not this time, anyway.

But he did finish with some philosophy.

Atomic Transactions are like Singularities. Singular points in space and time. Two phase commit makes time problems go away. Changes in our industry, moving away from mainframes to minis, from monoliths to services, introduce distance into the equation. Interchangeability of parts makes space and time effects surmountable.

Summary

Services offer us a different paradigm to traditional transactional processing. Always consider:

  • Explicit Boundaries – autonomy of services
  • Acceptance is Different – Confirm and Cancel, not Commit
  • Semantics – Intricacies should be avoided
  • Interchangeability – Variance prevents interchangeable operations

TechEd-Developers

Technorati Profile

Technorati Tags: Microsoft, SOA, TechEd 2007

Implementing the Enterprise Service Bus using BizTalk

Fri, 9 November 2007 13:32 GMT

Robert Hogg – Black Marble Ltd
Richard Fennell – Black Marble Ltd

Microsoft ESB Guidance

  • For BizTalk Server 2006
  • Architectural Guidance
  • Reusable Components
  • Sample Applications
  • Connection for Governance
  • Management Portal

Amberpoint and SOA Technologies have governance products that bolt straight into the ESB Guidance platform.

Components

  • On Ramps and Off Ramps – context based routing (e.g. Can use BRE or UDDI to decide which service to invoke)
  • Exception Management Framework
  • SharePoint Management Portal
  • Web Services
  • Core Services

On-Ramps

  • Standard BizTalk Ports
  • SOAP Receiver
  • WSE Receiver
  • JMS Receiver
  • Custom Receiver

Off-Ramps

  • SOAP Generic Send Port
  • WSE Generic Send Port
  • JMS Generic Send Port
  • Custom Generic Send Port

Core Services

  • Transformation services
  • Agents to do work
  • Extensible
  1. Define Itinerary of Services
  2. Publish Message
  3. First Step of Itinerary identified
  4. Message routed to First Step
  5. Second step of Itinerary identified
  6. Message routed to Second Step

Web Services

  • Resolver
  • Transformation
  • UDDI
  • BizTalk Exposed over Web Service!

Exception Management

  • Exception Web Service – usable in lots of other scenarios; not just ESB!

Testing

  • ESB Client Tool
  • ESB Management Portal

Installation Notes

  • Windows Server 2003 R2
    • Install UDDI
    • Patch Patch Patch
  • BizTalk 2006 R2
  • Install eb Extensions for Visual Studio 2005
    • (Included in SP1 for Visual Studio 2005)
  • BAM Sheet requires Analysis Services (unles you check real time aggregation)

Road to SOA/ESB Failure
Typically one or more of:

  • Lack of comprehension of business needs
  • IT first design
  • Poor management
  • Poor implementation

Plan for SOA inside your Business

  • Using service oriented technologies does not guarantee success
  • Understanding the goal of service orientation is key

For ESB Use Microsoft Guidance

Technorati Profile

Technorati Tags: BizTalk, ESB, SOA, TechEd 2007