Microsoft Application Center 2000 is one of the .NET Enterprise Servers that will ship in the coming weeks. Application Center is a set of tools and services that lets you manage a farm of IIS Web servers as if they were one machine. In Application Center 2000, this concept of grouping servers to facilitate managing them as a whole is called an Application Center "cluster." You can create clusters or add and remove member servers from existing clusters. When you've defined a cluster, you can automatically deploy new content to the cluster group as a whole, configure load balancing, and monitor cluster performance.

An exciting feature of Application Center 2000 is request forwarding, which is also one of the most difficult features to conceptualize. Let me provide a little background about the problem. In contrast to programming Windows (or Win32) applications, Web programming is difficult because it's difficult for Web developers to maintain session state, or "coherency," between pages. Session state is a temporary store for user session information, such as user preferences, shopping baskets, and other user-specific information.

Because TCP/IP is a stateless protocol, a Web developer can't automatically make the value in variables set in one Active Server Pages (ASP) file available in the next ASP file (as they are automatically between forms in a Win32 application).

In a load-balanced, multiserver environment, managing and resolving session state for individual clients is even more complex. Hardware and software load balancing solutions include features to ensure that a client remains "sticky" to the server from which that client first requested a file (i.e., "server affinity"). For example, in large ISPs, a user makes a page request on the Internet, and a server serves that page from a New York data center. A user makes another page request, and a server serves the page from a Los Angeles data center. These load balancers can't retain server affinity if they don't know exactly where the client request is coming from. The load balancer assumes that a new client is connecting and that the balancer load balanced that client to the most available server and created a new session.

Microsoft designed Application Center Request Forwarder to resolve these session state problems when handling HTTP client requests. Request forwarding lets you cluster applications and preserve session state, in most cases without modifications. Application Center Request Forwarder has the following features:

  • Transparent to clients—Clients aren't aware of request forwarding beyond the requirement of accepting cookies.
  • Transparent to server applications—IIS applications are unaware of any request-handling problems that request forwarding solves.
  • Format generic—Application Center applies generic policies to specific HTTP verbs and parts of the URL namespace so that applications requiring session coherency or single-server execution can use request forwarding.
  • Easy to configure—No configuration is required to use request forwarding.
  • Distributed—Processing on the forwarding server is minimized; the bulk of the processing takes place on the original server that handles the client request.

Request Forwarder sits between the HTTP client and server applications (e.g., between ASP and Internet Server API—ISAPI). The tool stores information that identifies the sticky server in an HTTP cookie, then returns this cookie to the client on its first trip. On subsequent client requests, Application Center checks the cookie to see which server first handled the client during a given session. If a load balancer sends the request to a server other than the original, Request Forwarder reroutes the request automatically to the sticky server, thereby handling the problem of server affinity.

Now, here's the best part. In the case of a catastrophic failure, such as a network board dying in one of the Web servers in your farm (Application Center cluster), Application Center automatically senses a dead server, and Request Forwarder automatically forwards requests from the dead server to another capable server in the farm.