Architecture Overview

AppLogic is a grid operating system for scalable web applications and services. AppLogic runs distributed transactional and streaming applications on grids of commodity hardware. It does not require a SAN or other expensive shared storage, and is open and vendor-neutral. What's more, AppLogic is completely compatible with existing web applications.

Despite all the buzz about grid computing, so far grids have been limited to running computational applications such as business intelligence, simulations, derivatives trading, etc. However, the vast majority of Internet services and business applications are not computational; instead, they process large numbers of relatively small concurrent transactions (transactional applications) and/or deliver content (I/O intensive applications).

AppLogic is the first grid operating system that is designed for web applications and is optimized for transactional and I/O intensive workloads. It uses advanced virtualization technologies to ensure complete compatibility with existing operating systems, middleware and applications. As a result, AppLogic makes it easy to move existing web applications onto a grid without modifications.

Figure 1 illustrates the architecture of AppLogic. The system runs on a hardware grid assembled from commodity servers connected via Gigabit Ethernet interconnect. Some (or all) of the servers are expected to have directly attached storage - inexpensive IDE/ATA/SATA hard drives which AppLogic uses to provide a distributed storage pool for applications. AppLogic includes three major subsystems:

• Distributed Kernel - abstracts and virtualizes the grid hardware, and provides core system services
• Disposable Infrastructure Manager - handles the infrastructure for each AppLogic application
• Grid Controller - provides a central point for managing and monitoring the grid.

Together, these three subsystems provide the foundation for executing and scaling existing web applications on grids of commodity servers.

The architecture of AppLogic is unique in four important aspects:

AppLogic makes Linux and Windows an integral part of the infrastructure

The conventional approach requires every new OS to implement a set of API to which applications must then be written or ported. Rather than doing this, the design of AppLogic recognizes the fact that conventional OS such as Linux and Windows are very good at managing software on a single computer - what's missing is the ability to manage and operate distributed applications.

AppLogic uses virtualization to enable each disposable infrastructure component to run on its own copy of Linux or Windows and focuses on providing the abstractions and services needed at the distributed application level. This approach results in a system that is very robust, while capable of integrating and running existing software unchanged.

AppLogic makes infrastructure an integral part of each application

Traditionally, you have to build a common infrastructure from firewalls, load balancers, web servers, application servers, database servers, etc. and then deploy multiple applications on it. The use of disposable infrastructure enables AppLogic to reverse this process and include the infrastructure required to run a given application within the application. Whenever a given application is started, the system automatically manufactures and assembles the infrastructure required to run it. Once the application is stopped, AppLogic disposes of all infrastructure associated with it.

This dramatically simplifies both the construction and the operation of N-tier applications: building infrastructure for each individual application is much simpler than building and managing shared infrastructure. More importantly, including the infrastructure within each application makes applications self-contained and portable and enables AppLogic to instantiate them on demand and migrate them from one grid to another.

AppLogic treats distributed applications as first-class objects

AppLogic treats the entire N-tier application as a single logical entity that can be copied, instantiated, configured, started, stopped, cloned, exported, imported, etc. As a result, once the application has been integrated and tested, it can be manipulated with remarkable ease.

The user can scale an instance of the application from a fraction of a server to dozens of servers simply by defining how much CPU, memory and bandwidth are to be allocated to that specific instance. Any number of instances of the same application can be executed simultaneously on the same grid. Multiple, unrelated applications can share the grid. Finally, an instance of an application can be cloned, together with its state, database and content, and exported to run on another grid that may be located half-way around the world.

A grid operating system for web applications

These capabilities enable AppLogic to provide the core set of functions that are essential for running mainstream web applications. Those include:

• Ability to aggregate commodity servers into a single scalable grid
• Native support for transactional and I/O intensive workloads
• Allowing an unmodified application to run on different grids
• Concurrent execution of multiple unrelated applications each with its own resource quota
• Scaling applications from a fraction of a server up to the full resources of the grid
• Supporting hardware, middleware and applications from a variety of vendors

In addition, AppLogic implements a number of key services that enable the building of real-world utility computing systems. These include:

• Resource metering system - enables pay-per-use models
• Catalog delivery system - handles the global distribution and sharing of infrastructure, prepackaged applications and software updates
• Grid management system - manages a datacenter as a single system

The following sections will cover in more detail some of the unique technologies that make all this possible. Those include the structure of AppLogic applications, key elements of the disposable infrastructure layer that makes the applications possible and the scalable system services required to support application creation, execution and management.

-- VladM - 22 May 2006