Method and system for performing deployment management

A system, method, computer program product are shown for automatically performing deployment activities that can handle deployments for any-sized organization, even for deployments at the enterprise level. According to some approaches, modeling is performed to generate a model of the components in the computing environment. Dependency graphs can be generated for the deployment, and used to then automatically perform the deployment.

FIELD

The invention relates to the field of deployment management.

BACKGROUND AND SUMMARY

In the computing field, the term “deployment” refers to the act of implementing software and computing resources into a computing environment. Examples of deployment activities include provisioning, patching, and configuration/reconfiguration. Provisioning refers to the distribution of software and resources into the computing environment, and is often used to in the context of an installation of fresh software on an enterprise hardware infrastructure. Patching refers to the act of updating or modifying the software and resources, and is often used in the context of the periodic activity of deploying fixes for problems/bugs that are reported after the main release of software. Configuration and reconfiguration refer to the acts of implementing or changing the properties or variables for the software, resources, or computing environment.

Conventionally, deployment is a task that requires significant human intervention to ensure that deployment activities are properly and optimally orchestrated for a given software/architectural environment. The software/architectural environment is often referred to as the software “stack” or “topology”. It is often required that such operations are performed while strictly adhering to the guidelines established by the vendors of the software and other architectural components.

One possible approach to implement deployment activities is to manually perform each and every step of the deployment. In this approach, highly skilled IT personnel would receive documentation that describe the deployment activities, and would manually follow the documentation to take every action that is needed across all of the components in the topology to perform the deployment.

Unfortunately, the manual approach is just not feasible when considered in the context of a large modern organization. For example, at the level of an enterprise, manually performed deployment activities would be excessively costly and time-consuming due to the extensive quantity of the items often being deployed as well as the complexities of the environments in which the deployment needs to take place. This is particularly problematic for the typical IT department at the data center of a large-scale corporation which handles the needs of a very large number of applications and users spread across many types of computing architectures and topologies. Attempting to perform deployment in a manual manner in this type of environment would be a very error-prone, time-consuming, and difficult task.

Another possible approach is the template or procedure-based approach for deployment, in which templates and/or procedures are distributed by vendors to accomplish the deployment activities. In this approach, the template/procedure corresponds to a particular deployment scenario or use-case, and has the requisite scripts, programs, and associated files to perform the deployment for that particular deployment scenario. The customer would fill in certain fields in the template that are specific to the customer, such as IP addresses and machine identifiers, which allows the scripts, programs, and files to be used to correctly implement deployment in the customer's environment. The drawback, however, with this template-based approach is that it is highly specific to the particular deployment scenario or use-case to which it is directed. When the customer environment is different from the expected deployment scenario or use-case, then the template may no longer be useful, or it may require the customer to perform many highly manual activities to customize the materials so that they are useful in the customer environment.

Therefore, there is a need for an improved approach to implement deployment, particularly for enterprise deployments, which addresses the drawbacks associated with the prior solutions.

Embodiments of the present invention provide an approach for automatically performing deployment activities that can handle deployments for any-sized organization, even for deployments at the enterprise level. According to some embodiments, modeling is performed to generate a model of the components in the computing environment. Dependency graphs can be generated for the deployment, and used to then automatically perform the deployment.

DETAILED DESCRIPTION

The present invention is directed to an improved approach for performing deployment activities. The invention addresses the issue of deployment for a variety of configurations, and is a generic method as opposed to the solutions which work only for well-defined software configurations. The inventive approach is “intelligent” as it accomplishes such activities with minimal or no human interference. According to some embodiments, the invention establishes dependencies in the topology and also determines any software version relationships. The approach is optimal as it performs such activities in a best-practice fashion as established by an enterprise, and ensures that software applications are stopped for zero or minimal possible time during such tasks.

Examples of deployment activities implemented by the invention include provisioning, patching, and configuration/reconfiguration. For the purposes of illustration, some embodiments may be described in conjunction with specific deployment activities, such as patching. It is noted, however, that the described invention may be applicable to any type of deployment, and is not to be limited to the specific examples shown unless claimed as such.

Embodiments of the invention are implemented with orchestration of the deployment activities such that vendor and supplier best-practices are adhered to, where the end-result of the configuration is a supported configuration for each of the components that are a part of the topology. In addition, the orchestration ensures that the deployment is performed in the correct order in consideration of dependencies between components in the topology. The orchestration also ensures that co-requisite/pre-requisite and post-requisite changes are factored in. Finally, embodiments of the invention can optimize to minimize the overall downtime of applications, or of particular software processes should be minimized.

These are activities for which it is that just not feasible to be performed manually for most organizations, using conventional technologies. Further, given the complexity of modern enterprise software stacks, any manual orchestration would not produce an optimal result. The embodiments of the present invention provide an automated approach that significantly reduces the costs of performing deployment, reduces errors, and can handle any type of topology and is not limited to particular well-defined software topologies.

Embodiments of the invention provide features to understand the software dependencies, and to orchestrate the deployment tasks in the correct order. This type of orchestration to identify dependencies is very difficult to perform manually. Moreover, this orchestration becomes even more difficult if one has to ensure high-availability, e.g., where execution of these operations should be such that the software processes are not required to be shut down, or are brought down for the minimum time possible.

To explain, consider the example topology shown inFIG. 1, which includes components at three different tiers. A first tier120is at the application level, a second tier122is at the application server level, and a third tier124is at the database level. The application tier120is illustrated shown to include applications106a,106b,106c, and106d. The application server tier122includes application servers108a,108b,108c,108d, and108e. The database tier124includes database servers110a,110b,110c, and110d.

Components at each tier interact with components at other tiers in a manner that causes certain dependencies to exist. In this example, application106ais downstream of, and dependent on, application server108bbeing available. Application server108b, in turn, is downstream of and is dependent upon database110bbeing available. Therefore, this is an example of a situation in which a first software process (e.g., for application108a) depends on a second software process (e.g., for the application server108b), and if the second process for the application server108bis to be patched, then patching this second process may requires stopping all dependencies such as the first process for the application106a. This chain of dependencies exist as well for the other components shown inFIG. 1.

Even within a single node in the topology, the deployment activities can be fairly complex. For example, there may need to be a certain order to deployment steps, e.g., relating to configurations, patching, running scripts to bring the node up or down, downloading contents, etc. When these activities are considered in the context of an extensive topology having many different nodes, and where the nodes themselves have dependency inter-relationships, the complexities can be overwhelming.

As is evident, the complexity and inter-dependency of software components ensures that conventional approaches which are manual in nature are not sufficient to accomplish enterprise-wide patching and provisioning. Embodiments of the invention provide an approach for automatically identifying these dependencies and to perform deployment for a variety of configurations. Some embodiments can greatly reduce the complexities of managing large configurations by managing the entire topology as one entity.

FIG. 2illustrates a system200for implementing deployment management according to some embodiments of the invention. System200may include one or more users at one or more user stations224that operate the system200to manage deployment for a topology240of components, such as application software206and software that runs on an applications server and/or database210. However, deployment management may be performed for any type of component or service in any type of topology according to embodiments of the invention.

User station224comprises any type of computing station that may be used to access, operate, or interface with a deployment manager214, whether directly or remotely over a network. Examples of such user stations224include workstations, personal computers, or remote computing terminals. User station224comprises a display device, such as a display monitor, for displaying processing results or data to users at the user station224. User station224also comprises input devices for a user to provide operational control over the activities of some or all of system200.

Deployment manager214provides management for some or all of the deployment services utilized in system200against a topology240of components. The deployment manager214comprises one or more deployment modules216to perform activities of deploying deployment data218to a topology240of components, such as the application206, application server208and/or database210. The deployment data comprises data corresponding to information needed to perform deployment activities to a topology240of components. Such deployment data216comprises, for example, software to be provisioned, images to be patched to an application, and/or configuration data or settings.

According to some embodiments, the deployment manager accesses one or more models220of the components in the topology240to perform deployment activities. The models220comprise a representation of the components in the topology240that captures the dependencies and relationships of the different members of the topology240. The models220also capture an inventory, metadata, and deployment information for the components in the topology240.

According to some embodiments, model220can include, or be represented as, a graph of dependencies222for the software in topology240. The graph of dependencies222identifies the dependent relationships between the software components in the topology240, where analysis of the graph can be performed to determine the dependent order of deployment for the topology240.

FIG. 5shows an example dependency graph502for the components of the topology shown inFIG. 1. Dependency graph502shows that application server108ais downstream of, and dependent upon, the availability of database110a. The dependency graph502also shows that application106ais downstream of, and dependent on, application server108bbeing available. Application server108b, in turn, is downstream of and is dependent upon database110bbeing available. Applications106band106care both dependent upon a single application server108c, which in turn is dependent upon database110c. Application106dis dependent upon two application servers108dand108e, which are both dependent upon the same database110d.

The models220also include metadata and deployment information for the components in topology240.FIG. 4shows an illustrative example of a model402that may be used to represent an application server according to some embodiments of the invention. Model402includes a first portion404to hold general metadata about the application server, such as for example, name-value pair information, port numbers, and other relevant identifiers.

Model402also includes a section406to hold deployment operation information for the application server. Such deployment operation information identifies the deployment procedures that pertain to the component in question. In the present example, the illustrative deployment procedure set forth in model402for an application server is a three step process to first bring down the application server, then perform the deployment procedure (such as a patch), and finally to bring up the application server. One or more scripts, procedures, or utilities may be identified to perform these actions. The operation steps could be customized for the different deployment activities of provisioning, patching, or reconfiguration. Those of ordinary skill in the art will recognize that this illustrative example provides a very simple series of steps for the deployment; of course an actual implementation of the invention may involve much more complex deployment procedures and steps depending upon the type of component being modeled.

Exceptions and optimizations to the deployment procedures may also be set forth in model402. These exceptions and optimizations provide additional handling actions that can be taken to improve the performance of the deployment or to handle special situations relating to the deployment. For example, a possible exception is to establish that the component will be deployed in a standalone mode if there are no dependencies, to avoid taking incurring dependency-related overhead or take actions that otherwise may be taken if there are dependencies upon the component. For instance, if there are dependencies, then the deployment manager may need to bring down a whole chain of dependent components before patching the one item of software that is at issue. If there are no dependencies, then the patch may be performed in a standalone mode where only the software being patched is brought down. Another possible exception may relate to ordering exceptions with regard to components in the topology. Other and additional exceptions and procedures may be employed within embodiments of the invention.

The models can be constructed to address any post or pre deployment activities that need to occur to the components. For example, it is possible that pre-deployment or post-deployment configurations must occur as part of the deployment activities. Such activities can be expressed as part of the deployment procedures in section406of the model402. The model402can also take into account any concurrent activities that must occur for the deployment.

Model402may also include a portion408to identify the relationships for the component being modeled. For example, an application server may have a downstream dependency relationship to applications and an upstream dependency relationship to databases.

While the above illustrate example of a model402is directed to an application server, it is noted that a similar model may be implemented for any component in the topology. The model can be implemented as a generic model for certain types of components, e.g., with a generic model for the application, application server, and database. Alternatively, the model can be customized for individual components in the topology.

The current solution enables the user to deploy all software in a topology using the models, where the deployment is orchestrated so that the downtime can be reduced by a considerable amount. The present approach takes the list of deployment items and components being patched, e.g., patches and the software targets being patched, and then determines out the best path based on the dependency graph.

FIG. 3shows a flowchart of a process for performing deployments according to some embodiments of the invention. At302, one or more models are constructed for the topology and/or topology components. The model(s) comprise dependency information and deployment metadata for the topology components. Examples of such models are illustrated inFIGS. 4 and 5. Topology models can be constructed in any suitable manner, e.g., by using agent based discovery. The models should include novel metadata, e.g., as represented by the operational metadata shown in406ofFIG. 4

At304, the process builds a dependency tree of the specified targets. The dependency tree is based at least in part on the type of the target(s) being deployed to. The dependency tree comprises root and/or leaf nodes corresponding to the components in the dependency graph which are affected by the deployment. For example, as shown inFIG. 5, one possible root node is database110band its corresponding leaf node is application106a. The dependency tree can be used to identify the dependency relationships between the various components that should be operated upon for the deployment.

The dependency tree is analyzed, at306, to determine the paths from root nodes to leaf nodes in the tree, and a determination is made at308of the number of such paths. The general idea is that the deployment activities can be optimized based upon the exact portion of the topology affected by the deployment, as well as the dependency relationships for those nodes in the affected portion of the topology. The optimizations can be made to reduce the downtime of components in the topology and to increase the availability of software and systems to users.

For example, consider the situation when both an application and its associated database need to be patched. It is likely that each component will need to be brought down to perform the patching activities for that component. In addition, because there is a dependency relationship between these two components, then both may need to be brought down when only one of these is being patched, e.g., both the application and the database need to be brought down when the database is being patched. As a result, to minimize downtime, the invention could patch both the application and the database in a single downtime session by piggybacking the application patch to the time when the database patch is occurring. This reduces the downtime that may occur if the patching activities occur in two different sessions.

Therefore, the present approach will look at the targets of the deployment activities, as well as their interrelationships. If any target has only a single node, then it is a single node tree and does not have any paths between root and leaf nodes, and therefore this means that the target is an independent target which can be patched/deployed to at309without any dependency issues as standalone software.

If there is only one path from root node to the leaf node, then at310, all the software targets can be patched/deployed to in single downtime window. In this case, the downtime for the root node will be the sum of patching for each of the child nodes. This situation can also be handled by performing the deployment separately for both nodes, which is less optimal in some situations since it will involve two separate downtimes.

If there are two or more paths from a root node to the leaf node, then the process will, at312, first patch/deploy to the root node. Next, at314, the process will patch the second level nodes ensuring that at least one path is available from root node to leaf node. This continued from316back to314until the leaf nodes are all patched. The downtime of the root node in this situation will be the time required for patching that node.

To illustrate this process, consider the following generic configuration that can be extended to a variety of cases, for the purpose of understanding this method. A use case is the patching of an application Human Resource Management System (HRMS). The application runs on an Application Server, which uses a Database. These software components require an operating system. Also they may reside on a single machine or on different machines. Moreover they can be distributed across multiple distributed machines (e.g., using the Real Application Clustering (RAC) technology available from Oracle Corporation of Redwood Shores, Calif.). In this scenario, deployment for the complete topology should be orchestrated to ensure a least downtime period for the application when patching to the whole set.

Consider if the application HRMS is being deployed on two Application Servers (A1and A2) and these are running using two Database Servers (D1and D2), with all of these running on two Hosts (H1and H2). Assume that a dependency tree is constructed having the following dependency relationship:Application depends on Application ServerApplication Server depends on Database, where the Application Server uses the Database for the correct functioning of the applicationsThe Database and Application Server depends on the Host.

Here, the HRMS is the root node and the H1/H2are the leaf nodes. There are several possible paths from root node to the leaf node:HRMS->A1->D1->H1HRMS->A1->D2->H2HRMS->A2->D2->H2HRMS->A2->D2->H1

The above paths can be used to ensure the application HRMS is down only for the time required to patch only this application. In this case, the following actions are performed:a. First patch the HRMS applicationb. Next patch A1, D1and H1c. Then patch A2, D2and H2

With the above actions, the application HRMS will be down only during step (a) and will be available while the other supporting soft wares are being patched. The above use case only considers patching one node. Moreover the patching algorithm assumes that patching requires shutting down software, replacing bits, and restarting the software. However the graph algorithm can be extended to handle a variety of test cases such as 1) patching multiple software components (equivalent to nodes in a dependency graph) 2) patches in (1) above may be co-/pre-/post-requisite patches 3) other deployment activities such as provisioning and cloning can be interspersed with patching 4) multiple applications may be running on a farm of application server 5) operating system patching and provisioning can be part of the enterprise deployment operations.

As additional illustrative examples, consider if it is desired to patch the software on the application server tier122shown inFIG. 1, which includes application servers108a,108b,108c,108d, and108e. Recall thatFIG. 5shows an example dependency graph that has been modeled for the topography ofFIG. 1.

Consider first the actions for patching to the software on application server108a.FIG. 6Ashows the dependency tree that is constructed from the dependency graph ofFIG. 5when it is desired to patch to application server108a. In this example, there the dependency tree shows only a node for the application server108a. This is because there are no other nodes that are dependent upon the application server node108a, and therefore the dependency tree will not include any other nodes. As such, as shown inFIG. 6B, the patching of application server108acan be handled as if application server108ais a standalone node. Therefore, only the one application server108ais brought down at602(with no other nodes needing to be brought down at this time). At604, the software at application server108ais patched, and once the patching is complete, then application server108acan be brought back up at606.

Consider now the actions for patching to the software on application server108b.FIG. 7Ashows the dependency tree that is constructed from the dependency graph ofFIG. 5when it is desired to patch to application server108b. Here, the dependency tree includes two nodes, with the application server108bat the root node and the application106aat the leaf node. In this situation, this dependency tree clearly shows that there is at least one other node that is dependent upon application server108b, since application106ais dependent upon the application server108b. What this means is that since application106ais dependent upon application server108b, additional orchestration must be performed to ensure proper ordering of actions when performing the patching/deployment.

FIG. 7Bshows the process for performing a deployment in this situation. Because of the dependency of the application106ato application server108b, this means that coordination of both nodes must occur to handle the deployment to application server108b. Here, the leaf node106ais brought down first at702, followed at704by bringing down the application server node108b. At this point, with both nodes down, the application server108bcan be patched at706. Once the patching is complete, then application server108bcan be brought back up at710, and then the application is brought up at712.

Consider if deployment needs to occur for both the application106aand the application server108b. As can be seen fromFIG. 7C, the dependency tree for this situation is exactly the same as the dependency tree ofFIG. 7Awhen patching just the single node108b. Therefore, the potential downtime for both patching scenarios is exactly the same. In this situation, rather than engaging in two separate procedures for the deployments to the two nodes, the same downtime can be used to perform the patching for both nodes. This optimization therefore provides a way to accomplish required deployments within minimal downtime by using the dependency tree to recognize that additional patching can be “piggybacked” onto existing patching downtimes.

FIG. 7Dshows the process for performing a deployment in this situation. Because of the multiple patching that needs to occur, this means that multiple patching actions are performed. Here, as before, the leaf node106ais brought down first at722, followed at724by bringing down the application server node108b. At this point, with both nodes down, the application server108bcan be patched at726, followed by the patch of the application106aat728. Once the patching of the two nodes are complete, then application server108bcan be brought back up at730, followed by bringing the application back up at732.

Consider now the actions for patching to the software on application server108c.FIG. 8Ashows the dependency tree that is constructed from the dependency graph ofFIG. 5when it is desired to patch to application server108c. Here, the dependency tree includes three nodes, with the application server108cat the root node and the applications106band106cat the leaf nodes. In this situation, this dependency tree shows that there are two nodes node that are dependent upon application server108c, since applications106band106care dependent upon the application server108c. What this means is that since both applications106band106care dependent upon application server108c, additional orchestration must be performed to ensure proper ordering of actions when performing the patching/deployment.

FIG. 8Bshows the process for performing a deployment in this situation. Because of the dependency of both applications106band106cto application server108c, this means that coordination of all three nodes must occur to handle the deployment to application server108c. Here, the leaf node106bis brought down first at802and the leaf node106cis brought down at804. This is followed at806by bringing down the application server node108c. At this point, with all three nodes down, the application server108ccan be patched at808. Once the patching is complete, then application server108ccan be brought back up at810. At this point, both applications can be brought back up, with the application106cbrought up at812and application106bbrought up at814.

Consider now the actions for patching to the software on application server108d.FIG. 9shows the dependency tree that is constructed from the dependency graph ofFIG. 5when it is desired to patch to just the application server108d. In this example, there the dependency tree shows only one node for the application server108d. Even though there is an application node106dthat is dependent upon application server108d, this application node106dis also dependent upon another application server108e. So long as application server nodes108dand108eare not both brought down at the same time, this means that application106dhas a dependency path that will not be blocked by the deployment to application server108d. As such, the dependency tree will only include a single node for application server108d.

To minimize downtime, this means that only the single node for the application server108dwill be brought down for the deployment, allowing application106dand application server108eto stay up through this deployment process. As such, the patching of application server108dcan be handled as if application server108dis a standalone node. Therefore, the flow ofFIG. 6Bcan be re-used for this deployment process, with only the one application server108dbeing brought down at602with no other nodes needing to be brought down at this time. At604, the software at application server108dis patched, and once the patching is complete, then application server108dcan be brought back up at606.

Consider now the actions for patching to the software on application server108e.FIG. 10shows the dependency tree that is constructed from the dependency graph ofFIG. 5when it is desired to patch to just the application server108e. In this example, the dependency tree shows only one node for the application server108e. It is noted that this dependency tree ofFIG. 10is identical to the dependency tree ofFIG. 9, with the exception that single node inFIG. 10is108einstead of108d. However, like the previous situation described forFIG. 9, even though there is an application node106dthat is dependent upon application server108e, this application node106dis also dependent upon another application server108d, which means that so long as application server nodes108dand108eare not both brought down at the same time, then the application106dhas a dependency path that will not be blocked by the deployment to application server108e. As such, the dependency tree will only include a single node for application server108e. As before, to minimize downtime, this means that only the single node for the application server108ewill be brought down for the deployment, allowing application106dand application server108dto stay up through this deployment process. As such, the patching of application server108ecan be handled as if application server108eis a standalone node, with the flow ofFIG. 6Bbeing re-used for this deployment process with only the one application server108ebeing brought down at602with no other nodes needing to be brought down at this time. At604, the software at application server108eis patched, and once the patching is complete, then application server108ecan be brought back up at606.

Consider if the patching needs to occur for both application servers108dand108e.FIG. 11Ashows the dependency tree that is constructed from the dependency graph ofFIG. 5when it is desired to patch both application servers108dand108e. In this situation, the dependency tree shows the application106dalong with both application server nodes108dand108e. Since both application server nodes108dand108eare being patched, and application106dis dependent upon both applications servers, then additional orchestration must be performed to ensure proper ordering of actions when performing the patching/deployment.

FIG. 11Bshows the process for performing a deployment in this situation. Here, since there are multiple paths from the root node to the leaf node, this means that an optimization can be made to maintain uptime for the application106d. Therefore, application106ddoes not need to be brought down. Instead, each of the application servers108dand108ecan be separately brought down and patched to maintain uptime for the application106d.

At1102, application server108dis brought down, while keeping both application108dand application server108eup. The down application server108dis patched at1104, and once the patching is complete, then the application server108dcan be brought back up at1106. At1108, application server108eis brought down, while keeping both application108dand application server108dup. The down application server108eis patched at1110, and once the patching is complete, then the application server108ecan be brought back up at1112.

Consider if the patching needs to occur for the application106das well as both application servers108dand108e.FIG. 11Cshows the dependency tree that is constructed from the dependency graph ofFIG. 5when it is desired to patch both application servers108dand108e. In this situation, the dependency tree shows the application106dalong with both application server nodes108dand108e.

Here, it is not necessary to maintain the immediate uptime for application106d, since this node itself needs to be patched. Therefore, to minimize downtime, an optimization can be taken to make sure that all three nodes are patched in the same downtime window.

FIG. 11Dshows the process for performing a deployment in this situation. Here, the application106dis brought down first at1122. The application server108dis brought down at1124and the application server108eis brought down at1126. With all nodes down, the application106dand application servers108dand108eare all patched at1128. Once the patching is complete, then the application servers can be brought back up, with application server108ebeing brought up at1130and application server108dbeing brought up at1132. Once the application servers have been brought up, then the application is brought up at1134.

FIGS. 9-11Dillustrate examples of situations in which different optimizations may be taken depending upon the specific needs of the deployment. If application106ddoes not need to be brought down, then patching for each of the application servers108dor108ecan be separately handled to avoid bringing application106ddown, as described above.

It is possible that even if both application servers108dand108eneed to be patched, but to minimize downtime of application106d, then the patching occurs in two different sessions such that application106dnever needs to be brought down. This would involve the sequential implementations ofFIG. 9andFIG. 10where the patching to application servers108dand108eare handled in entirely different downtime sessions.

However, the application106dmay need to be brought down, e.g., because this node itself must be patched. In this situation, the system would take advantage of this required downtime to patch all of the application106d, application server108d, and application server108e. By handling the patching all at once, this limits the downtime to a single downtime session for all three components.

Therefore, what has been described is an improved approach for performing deployment in an automated manner. Prior to this invention, patching a set of software required a significant amount of manual work in orchestrating the process, with the distinct possibility that the required downtime defined for the applications/services is high. In contrast, embodiments of the present invention provide a universal approach that can be used with minimal manual interactions to perform deployment, and which can also minimize downtime.

One advantage of some embodiments is that end to end deployment can be automated and optimized for a variety of software stacks and is not limited to particular well-known use cases. In addition, enterprise deployment can be addressed for a new stack without requiring development of a new orchestration strategy catered for that configuration. The approach of various embodiments automatically generates the best possible policy for each configuration. Moreover, embodiments can be used to manage many products as one stack. This approach can be used to ensure minimum downtime, minimum business interruptions, and high-availability. In addition, all systems in the topology can be deployed under best-practices from developers and vendors. The approach also significantly reduces administration costs by reducing human intervention

System Architecture Overview

Computer system1400may transmit and receive messages, data, and instructions, including program, i.e., application code, through communication link1415and communication interface1414. Received program code may be executed by processor1407as it is received, and/or stored in disk drive1410, or other non-volatile storage for later execution. Computer system1400may communicate through a data interface1433to a database1432on an external storage device1431.