• Deploy: Rapid system roll-out, patching, change-control, roll-back of Linux systems and applications.
  
  
• Monitor: Provides visibility into Linux OS and application health across the data center. Detect conditions that impact application availability and performance before they do.
  
  
• Analyze: Create policies that define optimal conditions for your data center operations. Increase operational performance and decrease operating expenses by define management actions to remediate error conditions automatically.

The Levanta platform allows system administrators and IT managers to more effectively manage their Linux servers and applications. By providing monitoring, automation and systems management tools in an integrated hardware/software solution Levanta can reduce increase application availability, increase system administrator productivity and reduce management costs.

• Life cycle management: Provides bare-metal provisioning, application roll-out and patching capabilities for many popular Linux distributions. Drag-and-drop deployments and migrations are completely quickly and repeatably using our reusable system templates.
  
  
• Monitoring: System and application health is continuously monitored using our built in industry-standard monitoring capabilities. Monitors can be specified as part of your standard application stack, ensuring all critical systems are visible. Changes in monitored conditions generate notifications that can be routed to system administrators or remediated automatically.
  
  
• Management Console: Provides 360-degree visibility and control over your Linux server infrastructure. Life cycle management, monitoring and automation actions can be performed in this integrated management console.
  
  
• Automation Engine: System overload, hardware failure and misconfiguration all drag down application availability. The Levanta automation engine executes recovery actions to bring systems back on-line rapidly and without user intervention.
  
  
• Storage Management: Levanta solutions mediate storage access or administer filer devices to enable rapid Linux system provisioning. Levanta-managed servers can run entirely from a shared storage device, reducing the impact of individual system failures.
  
  
• Management Agent: Common life cycle management tasks are performed by a system agent that provides powerful software deployment, patching and roll-back services. The agent is deployed as part of the initial server provisioning from bare metal.
  
  
• Monitoring Agent: Gathers information from managed servers to identify capacity and performance issues before they impact the business. Current conditions of the managed Linux servers and the Levanta platform are processed then displayed in the management console.
  
  
• Rules Engine: The Levanta rules engine finds the needle-in-the-haystack of monitoring information, notifying system administrators and the automation engine when out of tolerance conditions are discovered.

Levanta's platform leverages shared storage (iSCSI or Fiber Channel attached storage, filers or the Intrepid itself) to provide the persistent state of the systems it manages. By using shared storage Levanta's solution is faster than imaging or script-based approaches to systems management. Imaging or scripting approaches are forced to perform lengthy copying operations to direct-attached storage (DAS) slowing deployments, upgrades and system recovery.

Levanta's innovative approach to Linux Data Center Automation enables organizations to quickly leverage the speed and cost advantages of Linux and industry-standard hardware for their business-critical applications and services.

Combining Levanta's data center automation solution with shared or clustered storage enables systems to be deployed and managed quickly and efficiently. Levanta's state-based approach to systems management is faster and more flexible than image-based products and requires none of the 'guru-level' Linux knowledge required by a scripted or procedural solution.

Systems Management, Monitoring, Automation – one solution
Levanta's Data Center Automation presents a complete view of your Linux system assets and provides intuitive monitoring and policy specification capabilities.

The Trouble with Linux Management
Traditionally, change and configuration management have been handled in two ways: using image-based and procedural methods. Both approaches fall short on Linux systems. Neither method is technologically efficient for a large number of servers, and both require a great deal of manual configuration work -- creating an overall slow and cumbersome process. The result is a state of "diminishing returns" as more machines are added to the system. Also, in both approaches, the operating system (OS) is "tethered to the hardware," calling for complex and slow duplication procedures each time a change is rolled out.

Limitations of Image-Based Management
The image-based management technique essentially makes an image of the entire file system and clones the drive. While this "make-a-copy-of-everything" methodology works reasonably well for mass production, it has a number of disadvantages as a mechanism for change going forward.
 
First off, image-based solutions typically break down any time a hardware change is introduced, no matter how small. Also, this is an all-or-nothing approach that requires administrators to update every copy of the OS and patching of applications, for example. Insiders like to call this approach "blow & go": wipe the slate clean and start over, repeatedly. This method works in homogenous environments only, and rollbacks are not supported. Thus, this technique is really only useful for server provisioning rather than change management. In addition, there is no audit trail to help companies track system changes over time. And imaging proceduresare both network and storage hogs, creating significant barriers to ad-hoc deployment when it is needed most, at times of high load.
 
Examples of this technology are products from Altiris, Veritas' OpForce, and Symantec Ghost.

Limitations of Procedural Methods
Procedural approaches automate the installation and change processes that are built into either the OS or the particular application or patch being deployed. They can be implemented by a software product, or developed in-house in reaction to evolving systems management needs. In either case, this is a highly labor-intensive process. There are numerous setup steps required for scripting, and this approach creates nested layers of complexity that necessitate ever more complex procedures. Attempts to undo a change or rollback to a previous state become more and more challenging over time. This difficulty with growth makes it problematic to create scripts that are flexible and therefore portable within server farms.
 
More importantly, it is particularly difficult to create scripts that will work across a large number of systems. And the resulting average speed of using scripts is generally only marginally better than using manual procedures in typical environments. These factors combine to make procedural approaches unscalable as the number and heterogeneity of managed machines increases. Moreover, the procedural approach is "state ignorant," meaning the administrator is only aware of changes when they go through the machine's procedural gatekeeper. The audit trail is therefore quite limited.
 
Examples of this technology include Opsware, BladeLogic, and HP Novadigm.

Most Wanted: Levanta's Vision
Levanta's vision is a new systems administration model that virtualizes the entire Linux software stack – OS, middleware, applications and configuration – to dramatically improve the speed and power of system administrators.
 
The important thing to understand is that Levanta uses shared storage, which has powerful advantages over storage tied to local disks. First, shared storage speeds provisioning by obviating the need to copy and format data to a local disk, while simultaneously providing the flexibility to move the operating and file systems from one machine to another at will. Secondly, shared storage essentially revolutionizes data recovery; while a failed processor can usually be readily replaced and operations quickly restored, a failed storage resource typically means time-consuming restoration work and often loss of critical data. A shared storage subsystem ensures that data resides "communally" in the system, making recovery faster and more complete.

What Levanta has done is to wed data virtualization to systems provisioning to offer an alternative method to achieving better Linux management. Levanta captures the state of a machine and everything about it using MapFS technology to keep track of the entire file system at all times. This "state-based" approach does away with the need for complex scripting procedures.

Transactional System Management
This new methodology, which we call "Transactional System Management" manages system state changes as if they were data, with full versioning and integrity semantics. Transactional system management can work immediately with existing applications and processes, so users are not required to overhaul systems in order to get started.

Checkpoints vs. Snapshots
Traditional full-scale system snapshots repeatedly copy the entire disk or changed blocks in what is known as a "block-level copy." In contrast, Levanta records multiple versions of a server's system states, called "checkpoints," which capture only the "delta" between a previous state and the newly updated one on a file-by-file basis. Checkpoints can be taken at whatever interval administrators want, either manually controlled or set up at regular intervals. This provides constant, automatic updates of every change to any piece of data. The checkpoint state-capture mechanism offers several major benefits.

First, since checkpoints work on the file system level rather than the block device level, they provide users a file-by-file view of what has been modified, created, or deleted in the system – versus a snapshot of the entire system that does not distinguish what has changed.

The use of checkpoints also eliminates the need to reformat the entire system when changes occur. Being "file system aware" means that checkpoints essentially extract the state of the machine from the underlying hardware, making it quick and easy to snap back to a previous configuration within a couple of minutes. This method therefore provides increased speed and granularity, and reduced storage consumption without requiring application or kernel changes.

• portability within your IT environment, which means provisioning or migrating machines in minutes
• comprehensive tracking, which facilitates easy rollback
• no image copying across the network, for a major speed advantage

Under the Hood: How Levanta Works
Levanta Intrepid is built on two logical groups of components: the Levanta Manager, which functions as the command and control center, and the Levanta Data Store, where all the "magic" of Levanta data virtualization takes place. The Levanta Manager is the basic control module, responsible for booting, hibernating, and restarting servers, initiating the checkpoint process, and basic UI communication functions. The Levanta Data Store houses the more distinct components – Levanta's Repository, Overlay and Smart Mirror – and therefore requires some deeper examination.

Again, the critical point is that Levanta uses shared storage. The software stack lives in a central location, rather than being installed on each machine individually. Levanta's solution is based on MapFS, a Linux kernel-loadable module developed by Levanta, Inc., under the GPL (General Public License) and available to the Open Source community. It is a virtual file system layer that simplifies data sharing between multiple Linux machines connected to a shared storage medium (SAN/NAS/Mainframe DASD).

MapFS works in concert with an existing file system. It provides application-transparent file redirection to allow file-sharing across the whole environment and provides a copy-on-write mechanism for any changes unique to an individual machine. Thus, Levanta's MapFS-based system works by creating an illusion, so that each system thinks it has its own copy of software. In reality, all software is located on a shared data store that is accessed across the network.

• This means you can deploy, rollback, and migrate RPM-based Linux servers (whether running Red Hat, SUSE, or Fedora distributions) from a central location, without installing the OS or applications directly on computers.
• Levanta employs a Network boot process to provision hardware from scratch, as opposed to other programs that require a floppy or CD; with Levanta, the system automatically boots off the network, with no need to feed anything additional into the machine.
• Using shared storage makes your Linux software and applications portable, allowing administrators to move entire software stacks around the IT environment without recreating the system. Changes can be undone, patches made, and new roll-outs accomplished equally rapidly.
• Levanta can provision hardware from bare-metal up to your applications. Levanta MapFS technology makes this fast and efficient.