Before using this information and the product it supports, read the general information in Appendix B. Notices.
This edition applies to Release 2.0 of the Autonomic Computing Toolkit and to all subsequent releases and modifications until otherwise indicated in new drafts.
This guide provides installation and user information for the Autonomic Computing Toolkit.
This guide is for system architects and designers, software developers, and testers interested in:
The latest softcopy versions of documentation are available on the autonomic computing IBM developerWorks Web site at:
www.ibm.com/developerworks/autonomic/
Refer to Documentation for a comprehensive list of available publications.
The HTML version of this guide and other related publications is accessibility-enabled for use with the IBM Home Page Reader.
For the latest news and tips on general autonomic computing topics, go to the autonomic computing Web site at:
You can also download the Autonomic Computing Toolkit, documentation, and access additional information from the developerWorks Web site at:
www.ibm.com/developerworks/autonomic/
Here you will find information about general autonomic computing concepts, an overview of the Autonomic Computing Toolkit, and most importantly, articles, and tutorials that show you how to apply the tools from the Autonomic Computing Toolkit in real-life situations. After you decide which pieces of the Autonomic Computing Toolkit you need, you can easily download the code right from this Web site.
Your feedback is important to help us provide the highest-quality information. If you have any comments about this guide, you can submit them on the IBM autonomic computing Web site at:
www.ibm.com/developerworks/autonomic/
and click on Support for Toolkit forum.
This chapter provides an introduction to the general terms of autonomic computing and explains the desired attributes of an autonomic environment.
The concept of autonomic maturity levels is also introduced. Understanding autonomic maturity levels is important to realizing how the Autonomic Computing Toolkit can help you develop autonomic capabilities that make IT environments easier to manage.
The autonomic computing reference architecture is then explained. The architecture provides an integrating framework for the technology content of the Autonomic Computing Toolkit.
Autonomic computing is a term used by IBM to describe the need to create a computing environment with the ability to manage itself and dynamically adapt to change in accordance with business policies and objectives. The autonomic environment will shift the burden of managing IT systems from IT professionals to the systems themselves. The term "autonomic" comes from the autonomic nervous system of the human body, the system that regulates the basic functions of the human body without one's conscious awareness. For instance, when you need to run to catch a train, you cannot consciously decide to produce adrenaline, reallocate oxygen to the muscles in your legs, and increase your heart rate. These important and necessary physical adjustments are handled for you automatically. In a similar way, autonomic computing systems handle more and more tasks on their own, without the need for intervention on the part of the IT staff. Autonomic computing behavior is necessary for building effective on-demand operating environments that adapt and adjust quickly to the changing computing needs of organizations.
Autonomic computing was conceived as a way to help reduce the cost and complexity of owning and operating an IT infrastructure. In an autonomic environment, system components-from hardware such as desktop computers and mainframes to software such as operating systems and business applications-become self-configuring, self-healing, self-optimizing, and self-protecting. These self-managing attributes are defined as follows:
These self-managing attributes are the core of an autonomic computing environment. They suggest that the tasks involved in configuring, healing, optimizing, and protecting the IT system are initiated due to situations that the technologies themselves detect, and that these tasks are performed by those same technologies. Collectively, these intuitive and collaborative characteristics can help enable enterprises to operate efficiently with fewer human resources, while decreasing costs and enhancing the organization's ability to react to change. For instance, in a self-managing system, a new resource is simply deployed and then optimization occurs. This is a notable shift from traditional implementations, in which a significant amount of analysis is required before deployment, to ensure that the resource runs effectively.
Incorporating autonomic capabilities into a computing environment is an evolutionary process enabled by technology, but it is ultimately implemented by each enterprise through the adoption of these technologies, supporting processes, and skills.
Products, systems, and IT environments can be classified in the following five levels of maturity that show how a business is evolving its use of autonomic capabilities and supporting processes and skills:
At the basic level, IT professionals manage each infrastructure element independently and set it up, monitor it, and eventually replace it.
At the managed level, systems management technologies can be used to collect information from disparate systems onto fewer consoles, helping to reduce the time it takes to collect and synthesize information as the IT environment becomes more complex.
At the predictive level, analysis capabilities are introduced in the system to monitor situations that arise in the environment, and analyze the situations to provide possible courses of actions. The IT professional makes a determination on what course of action to take.
At the adaptive level, the IT environment can automatically take actions based on the available information and the knowledge of what is happening in the environment. As analysis and algorithmic technologies improve and as people become more comfortable with the advice and predictive power of such technologies, systems can progress to the adaptive level.
At the autonomic level, business policies and objectives govern the IT infrastructure operation. IT professionals interact with the autonomic technology tools to monitor business processes, alter the objectives, or both.
The autonomic concepts presented in this section form the basis for a common approach and the base set of terminology needed in architecting autonomic computing systems in a heterogeneous environment.
The autonomic computing reference architecture starts from the premise that implementing self-managing attributes involves an intelligent control loop. This loop collects information from the system, makes decisions and then adjusts the system as necessary. An intelligent control loop can enable the system to have the self-configuring, self-healing, self-optimizing, and self-protecting attributes described before.
The architecture describes three types of system components-- autonomic managers, managed resources, and managed resource touchpoints. An autonomic manager is a component that implements a particular control loop. A touchpoint is a component that delivers access to the managed resource. A managed resource is what the autonomic manager is controlling. Figure 1 illustrates the relationship between the different components.
The autonomic manager is a component that implements the control loop.
The architecture splits the loop into four parts that share knowledge. They are:
The four parts work together to provide the control loop functionality. They consume and generate knowledge. This knowledge builds on known information about the system and grows as the autonomic manager learns more about the characteristics of the managed resources. The knowledge is continuously shared among the four parts, leading to more informed decisions being made by the parts. Figure 1 shows a structural arrangement of the parts--not a control flow. The bold line that connects the four parts should be thought of as a common messaging bus rather than a strict control flow. In other words, there can be situations where the plan part might ask the monitor part to collect more or less information. There could also be situations where the monitor part may trigger the plan part to create a new plan.
The managed resource is a controlled system component. There can be a single managed resource (a server, database server, or router) or a collection of resources (a pool of servers, cluster, or business application).
An autonomic manager communicates with a managed resource through the manageability interface. A touchpoint is the implementation of the manageability interface by a specific managed resource. For example, a database server might implement a touchpoint for communicating with an autonomic manager.
The touchpoint, one of the three main elements of the autonomic computing architecture, delivers the manageability interface to the autonomic manager.
The manageability interface between an autonomic manager and a managed resource is organized into sensor and effector operations.
In the simplest terms, sensor operations are typically used to transmit events or properties to an autonomic manager, whereas effector operations are typically used to cause some sort of change in a managed resource, such as altering state data or setting property values.
Sensor and effector operations are organized into a set of interaction styles that formalize and define how an autonomic manager and its managed resources interact. Sensor and effector operations each can have two interaction styles:
Interaction styles are differentiated by whether the autonomic manager or the managed resource makes contact first. In both the sensor retrieve-state interaction style and the effector perform-operation interaction style, the autonomic manager makes first contact. In the sensor receive-notification and effector call-out-request interaction styles, it is the managed resource that makes contact first.
The combination of sensor and effector operations forms the manageability interface that is available to an autonomic manager. As shown in Figure 1, by the black lines connecting the sensor and effector sides of the diagram, the architecture encourages the idea that sensor and effector operations are linked together. For example, a configuration change that occurs through an effector should be reflected as a configuration change notification through the sensor interface.
Further details of the manageability interface and interaction styles are described in the Autonomic Computing Toolkit Developer's Guide.
As described in Levels of autonomic maturity, autonomic maturity levels demonstrate that self-managing attributes are achieved in an evolutionary manner that permeates all aspects of a system. As an example, different parts of the autonomic manager could be implemented at each maturity level.
The monitor and execute parts of the autonomic manager could be implemented at the basic and managed levels. So, at these two levels, IT professionals would be responsible for performing the function of the analyze and plan parts.
The analyze part of an autonomic manager can be supplied at the predictive maturity level. At this level, the IT professional would be responsible for the plan function.
In the adaptive and the autonomic level, all of the parts of the autonomic manager are implemented so that the IT professional could delegate the work to the system.
The Autonomic Computing Toolkit is a collection of technologies, tools, examples, scenarios, and documentation that is designed for users who want to learn, adapt, and develop autonomic capabilities in their products and systems.
This release of the Autonomic Computing Toolkit provides the second phase of autonomic computing technologies that enable the development of autonomic capabilities. The content of the Autonomic Computing Toolkit can be divided into four main categories:
The technologies provided in the Autonomic Computing Toolkit can be used to develop or enhance certain capabilities in products and systems. These capabilities include problem determination, common systems administration, and solution installation and deployment.
Problem determination autonomic capabilities can be developed with the Autonomic Management Engine, the Generic Log Adapter, and the Log and Trace Analyzer tool.
The Integrated Solutions Console is used to build effective common systems administration capabilities.
The dependency checker and change manager are technologies that provide autonomic capabilities for solution installation and deployment.
These technologies are described in detail in Autonomic Computing Toolkit technologies and tools.
In addition to delivering these technologies, the Autonomic Computing Toolkit provides the tooling necessary to customize the technologies so that solutions can be created to meet the specific needs of each user. The Autonomic Computing Toolkit provides Eclipse-based tools such as the Integrated Solutions Console toolkit, Resource Model Builder (RMB), and the Adapter Configuration Editor tool.
The Autonomic Computing Toolkit also provides log parsers for several IBM products. These parsers, along with the parsers that you develop for your own products with the Adapter Configuration Editor tool, can be used to debug complex problems in a system environment.
These tools are described in detail in Autonomic Computing Toolkit technologies and tools.
Scenarios are also provided that show how the technologies work together and how they can be used in realistic situations. All the scenarios in the Autonomic Computing Toolkit are built using the technologies and tools available in the Autonomic Computing Toolkit. This release of the Autonomic Computing Toolkit includes a problem determination scenario performing self-healing tasks, as well as several automated installation scenarios performing self-configuring tasks.
These scenarios are described in detail in Autonomic Computing Toolkit scenarios.
The Autonomic Computing Toolkit also focuses on educating users on autonomic computing. Detailed individual technology and tooling documentation is provided along with documentation to help you begin developing autonomic solutions customized to your products.
This section outlines what you can do with the Autonomic Computing Toolkit and how to do it.
Before you try to develop an autonomic solution, it is best to get a good understanding of the concepts behind autonomic computing. See Autonomic computing concepts for more background information on the base concepts. The information in the Documentation bundle of the Autonomic Computing Toolkit (see Autonomic computing information), and on the Autonomic Computing Toolkit Web pages, also includes tutorials, articles, and other documents that you might find helpful.
After you gain an understanding of the basic concepts of autonomic computing, you can use the scenarios in the Autonomic Computing Toolkit to see how these technologies work together to achieve a self-management solution.
The Autonomic Computing Toolkit includes the following scenarios: a problem determination scenario demonstrating self-healing tasks and several automated installation scenarios demonstrating self-configuration tasks.
The problem determination scenario represents a simple self-healing system that uses an intelligent control loop to collect system information, analyze it, plan appropriate responses, and then make necessary adjustments to resolve problems. For more information on this scenario, see the Problem Determination Log/Trace Scenario Guide. Additional documentation is also included in the scenario bundle.
The Solution Installation and Deployment scenarios demonstrate how autonomic solution, installation and deployment technologies can be used to improve the packaging and installation of a simple application. Two scenarios are provided, demonstrating similar capabilities; however, each uses a different vendor software installation package. This shows the versatility and flexibility of the solution, installation and deployment technologies. For more information on these scenarios, see the Autonomic Computing Toolkit Solution Installation and Deployment Scenario Guide. Additional documentation is also included in the scenario bundles.
An additional scenario is provided that focuses on specific areas of solution installation and deployment by using a collection of samples. Each sample demonstrates a specific feature of the technology and how it can be applied to solutions.
As soon as you have an understanding of autonomic concepts, and have experienced how the Autonomic Computing Toolkit technologies work together to achieve a self-management solution, you can begin to develop self-management capabilities into your own products and help your customers increase the level of autonomic maturity in their IT environments.
The technologies available in the Autonomic Computing Toolkit can be used to help your customers achieve higher maturity levels in their IT environment:
The technologies and tools presented in this release of the Autonomic Computing Toolkit are intended to assist product developers in beginning to develop autonomic capabilities in their products, to help their IT environments achieve higher autonomic maturity levels. The technologies in the Autonomic Computing Toolkit can be divided into four categories, as shown in Figure 2.
Several examples of autonomic manager implementations are provided.
AME includes built-in capabilities for the four parts of the autonomic manager control loop (monitor, analyze, plan, and execute).
The Log and Trace Analyzer is an example of a partial implementation of the autonomic manager, covering the monitor and analyze parts of the control loop.
The Autonomic Computing Toolkit provides several technologies and tools to help developers create touchpoints that enable managed resources to communicate with autonomic managers. The Generic Log Adapter is included in the Autonomic Computing Toolkit to translate product log messages into the Common Base Event data format.
The Autonomic Computing Toolkit also contains tools to allow you to customize autonomic managers and managed resource touchpoint implementations. The RMB is used to customize the AME. The Adapter Configuration Editor is used with the Generic Log Adapter. The Integrated Solutions Console toolkit allows you to build custom plug-ins for the Integrated Solutions Console.
The Integrated Solutions Console component provides user access to the self-management capabilities. It is a Web-based infrastructure based on industry-standard technologies.
The Autonomic Computing Toolkit includes the autonomic management engine, an example of an implementation of an autonomic manager (see Autonomic manager for a definition of an autonomic manager).
AME monitors system resources, sends aggregated events, and performs corrective actions for problems. AME constantly monitors the system looking for events to handle.
AME is available in the Autonomic Computing Toolkit in the AME bundle.
A scenario demonstrating AME is included in the Autonomic Computing Toolkit. The scenario shows how AME can monitor for a situation, detect the situation, and provide corrective action. See the Problem Determination Scenario bundle information found in Autonomic Computing Toolkit scenarios, which describes the scenario and AME's involvement in more detail.
For additional information on developing solutions with AME, see the AME 1.1 Developer's Guide, provided in the bundle.
By defining a resource model for each managed resource, you provide AME with the knowledge needed to manage that resource. Resource models contain specific metrics, events, thresholds, and parameters, which are used to determine the health of your resources along with specifications for corrective actions in the event of failures. AME provides services for installing, starting, and stopping a resource model, and querying its state.
The Autonomic Computing Toolkit provides an Eclipse plug-in that you can use to create your own custom AME resource models, the RMB.
A sample AME resource model is provided in the Autonomic Computing Toolkit for educational and demonstration purposes. You can use this sample to learn how AME resource models are written and how they get tied into AME. The resource model sample is available in the Problem Determination scenario downloadable bundle.
For additional information on developing and using AME resource models, see the Autonomic Computing Toolkit Developer's Guide. For an example of an actual AME resource model, see the Autonomic Computing Toolkit Problem Determination Log/Trace Scenario Guide.
Solution installation and deployment technologies provide another implementation of an autonomic manager, as well as managed resource touchpoint implementations (see Autonomic computing reference architecture for a definition of these concepts). The autonomic manager functionality is provided by two components, a dependency checker and a change manager. Touchpoint implementations are provided for several operating environments. These technologies combine to provide a means by which software can be bundled and deployed across most operating environments.
The Autonomic Computing Toolkit provides scenarios that demonstrate these technologies and how you can use them to improve the packaging and installation processes for software solutions. Using these technologies can help you consistently plan for and deploy IBM and non-IBM solutions in less time and with fewer resources. See the Automated installation scenarios.
The Log and Trace Analyzer (LTA) is an example of a partial implementation of the autonomic manager, covering the monitor and analyze parts of the control loop (see Autonomic computing reference architecture for a definition of an autonomic manager).
The LTA enables viewing, analysis, and correlation of log files. This tool makes it easier and faster to debug and resolve problems within multitiered systems by consuming data in the Common Base Event format and providing specialized visualization and analysis of the data.
The LTA contains a log-analysis engine. The role of this engine is to provide an algorithm that takes an incident that is recorded in a log file as an input parameter, matches this incident based on a predefined rules against the symptoms of an available symptom database and returns an array of objects representing the solutions and directives for the matched symptoms. The LTA provides a default implementation of an analysis engine and a set of instruments that could be used to implement a custom analysis engine.
The Autonomic Computing Toolkit contains a default correlation engine as part of the Log and Trace Analyzer bundle. The capabilities include timestamp and record ID correlation. Also provided is the ability to create custom correlation engines.
The Log and Trace Analyzer (LTA) is available in the Autonomic Computing Toolkit in the Generic Log Adapter and Log and Trace Analyzer bundle.
For additional information on using the LTA, see the Log and Trace Analyzer User's Guide and other documentation provided in the bundle.
The Autonomic Computing Toolkit provides parsers for several IBM products. They are included in the Generic Log Adapter Runtime and Rule Sets bundle. The complete list of parsers and rules is provided in the online documentation for the GLA Configuration Editor contained in the Generic Log Adapter Runtime and Rule Setsbundle.
These parsers, together with the parsers you develop for your own product logs, could be used for debugging complex problems as you develop self-managing applications in a multiproduct system environment.
The agent controller can be used to import any type of log file remotely from any platform that the agent controller supports. The supported platforms of the agent controller include:
zSeries (R) platform iSeries (TM)platformThe agent controller provides the convenience of analyzing a log file from a remote machine without having to transfer a copy of the file to a local machine. For example, by installing the agent controller on an IBM eServer machine, users can use the LTA running on a Windows machine to import and analyze a log file that is continuously updated by an application running on the server.
For more information, seeAgent controller package .
The Generic Log Adapter (GLA) is an example of a technology that helps a product create an autonomic computing resource model touchpoint (see Managed Resource Touchpoint for a definition of a resource model touchpoint).
GLA provides the ability to take an IBM or non-IBM product log file and convert the messages into the Common Base Event data format so that the product can become a managed resource. GLA translates product log entries into Common Base Events for consumption by an autonomic manager. The Autonomic Computing Toolkit includes the GLA as a technology to help products adapt to the autonomic reference architecture without requiring the product to change the way it creates its log files.
A single GLA run time can be used to parse the log files of multiple products as long as the rules have been defined for each log message format. The adapter includes a handler that passes the Common Base Event information to the autonomic manager on the manageability interface.
The GLA is available in the Autonomic Computing Toolkit in the Generic Log Adapter Runtime and Rule Sets bundle.
A scenario demonstrating the GLA in a self-healing application is included in the Autonomic Computing Toolkit. In this scenario, GLA reads actual product log files in real time. By using a set of supplied parser rules specifically for the products in the scenario, the adapter translates each log message into Common Base Event format. GLA is demonstrated in the Problem Determination scenario bundle.
For additional information on using the GLA, see the GLA online help files and other documentation provided in the bundle.
The Adapter Configuration Editor Eclipse plug-in is used in conjunction with the GLA. It provides the tooling to create the specific parser rules that are used by the GLA at run-time to create Common Base Event objects.
The Adapter Configuration Editor is available in the Autonomic Computing Toolkit in the Generic log adapter/Log trace analyzer bundle.
For additional information on using the Adapter Configuration Editor, see the GLA online help files and other documentation provided in the bundle.
The central goal of the Integrated Solutions Console is to create a platform on which IBM and non-IBM products can build administrative user interfaces. Standardizing products to run on the Integrated Solutions Console platform gives them a more common look and feel and a more consistent behavior, because you are using common building blocks. Administrators can interact with multiple IBM and non-IBM products from a single browser-based console.
Integrated Solutions Console is based on WebSphere Portal, so administrative functions are handled through portlets, or components, within a single system. When an administrator adds new software, its administrative functions and help files are added to the common administrative system.
The Integrated Solutions Console Toolkit is the development environment for creating Integrated Solutions Console plug-ins and is included in the Integrated Solutions Console packaging. It includes the Integrated Solutions Console run time, Integrated Solutions Console Developer Info Center, Sample Integrated Solutions Console Components, an Integrated Solutions Console plug-in for IBM WebSphere, and an Integrated Solutions Console Eclipse plug-in to help you create console plug-ins
The Autonomic Computing Toolkit console is set up to respond to AME resource model scripts. These scripts adjusts status indicators as situations occur, keeping the administrators informed on their product's condition. It also functions as an example of how plug-ins might be created for other user-specific product administration applications. The Autonomic Computing Toolkit console is only an educational example and illustrates only one possible approach.
The Integrated Solutions Console component provides a full set of online documentation for the run time as well as the Integrated Solutions Console Toolkit. The following documentation is also available when the Integrated Solutions Console component is installed.
Refer to the Integrated Solutions Console documentation for more information on how to create your own plug-ins and the Problem Determination Scenario to see an actual example.
A specific Integrated Solutions Console component plug-in is provided in the Autonomic Computing Toolkit to support the Problem Determination scenario and the solution, installation and deployment technologies samples scenario.
One of the primary objectives of the Autonomic Computing Toolkit is to provide easy-to-understand samples of how autonomic solutions can be used to solve real-world problems. These samples are provided as a collection of scenarios that focus on specific attributes of an autonomic computing environment.
The four scenarios included in the Autonomic Computing Toolkit are simple representations of typical pain points that can be addressed using autonomic computing technologies.
The purpose of these scenarios is to demonstrate how the components of the Autonomic Computing Toolkit work together in order to solve real-world problems. These scenarios are supported with documentation and can be used as examples to help you develop your autonomic solution.
The Problem Determination scenario demonstrates the self-healing attribute that autonomic computing brings to a computing environment. In order for a system to be self-healing, it needs to be able to recognize that a problem has occurred, determine the cause, and then take the appropriate action to correct the problem. One method of achieving this is through a product's existing log files. One of the Autonomic Computing Toolkit technologies used in the scenario is the Generic Log Adapter that transforms product log file events into the Common Base Event data format.
The Problem Determination scenario shows how an autonomic manager, represented here by AME, can be used to detect an error situation between two IBM products by analyzing log/trace files and applying a corrective action.
The scenario uses two IBM products interacting with each other to demonstrate how a common Web-based problem is detected and resolved. A simple database product is included to perform basic database access queries. The queries originate from a Web application, also included in the scenario bundle.
The Integrated Solutions Console is another Autonomic Computing Toolkit technology that is used in this scenario. The scenario includes an administration console built with the Integrated Solutions Console technology. It is used to start and stop the scenario and also provides a method of inducing the condition for failure and status monitoring capabilities. The administration console starts the scenario in a steady state showing the normal operation of the two products. It then allows you to induce a database failure that gets picked up from the Web application's log files. The included AME resource model is programmed to recognize the database failure. After the situation has been detected by AME, corrective action is issued to the managed resource. Each stage of the control loop operation is displayed in the status panel of the administrative console. After it has been corrected, the Web application begins functioning again and the scenario returns to steady state.
The Problem Determination scenario illustrates the use of the technologies in the Autonomic Computing Toolkit to accomplish the following tasks:
Running and observing the Problem Determination scenario, you will be able to apply the same techniques to your own applications and design your own autonomic solution for Problem Determination. See the Problem Determination Log/Trace Scenario Guide for further details on installing, using, and modifying the scenario.
Self-configuration attributes can be demonstrated using the solution installation and deployment technologies available in the Autonomic Computing Toolkit. The benefits and versatility of the autonomic solution installation and deployment technologies are demonstrated by providing three different scenario bundles. Two of the scenarios use different installation software products from industry vendors to demonstrate a typical installation, while the third scenario provides hands on interaction of specific features of the technology.
The purpose of the scenarios is to demonstrate the concepts behind the solution installation and deployment technologies by showing installations of realistic software packages.
Each scenario consists of code along with a descriptor package that explains the contents and prerequisites. This descriptor package is an IU, and multiple units are grouped into solution modules. The installer software application reads the descriptor file before performing the actual installation and checks a database of installed software and hardware to determine if all of the prerequisites have been met. If they have, the software is installed and its information is added to a solution installation and deployment database. If not, the installer notifies the user of the failed dependency so corrective action can be taken.
Two of the scenarios provided are based on two different underlying packaging software applications. One scenario uses ISSI from InstallShield as the packaging software, whereas the other scenario uses InstallAnywhere from Zero G. The third scenario does not use third party packaging software, but rather a simple test client to perform basic installations.
See the Autonomic Computing Toolkit Solution Installation and Deployment Scenario Guide , included in the bundle, for scenario-specific information.
For more information on InstallAnywhere, go to the Zero G Web site at:
For more information on ISSI, go to the InstallShield Web site at:
This scenario uses samples to demonstrate specific features of the solution, installation and deployment technologies. The samples are included as part of the Autonomic Computing Toolkit's integration solutions component plug-in console. This provides a common look and feel to the problem determination scenario operation.
The purpose of the scenario is to avoid the overall complexity of a complete self-configuring solution by focusing on certain aspects of the technology. Each sample can be executed and evaluated independently. The listIU feature is also included so that the Solution Installation and Deployment registry can be examined after both installing and uninstalling the samples.
The following Solution Installation and Deployment samples are bundled in the scenario:
For each sample, the user is presented with a complete description of the sample, the deployment descriptor file specific to the feature being demonstrated, a dynamic log output, as well as the ability to install and uninstall the sample for re-evaluation.
See the Autonomic Computing Toolkit Solution Installation and Deployment Scenario Guide, included in the bundle, for scenario specific information.
In addition to the content, an infrastructure has been built around the Autonomic Computing Toolkit components to provide accessibility, packaging, and installation and support of the autonomic components. The Autonomic Computing Toolkit is accessible to users through an IBM Web site at:
www.ibm.com/developerworks/autonomic/
The Web site provides access to the contents of the Autonomic Computing Toolkit as well as a support structure for aiding you in using that content. Because the Autonomic Computing Toolkit includes a large amount of content, a packaging approach has been provided that allows areas of interest to be obtained quickly and easily, and without having to have knowledge of the individual components. The download bundles are set up to accommodate users at varying levels of autonomic expertise. The Web site guides you to the appropriate bundle based on your area of interest. Experienced users can go directly to the bundle of interest for quick downloading. The packaging has been set up to minimize the number of downloads by organizing the technologies, tools and other components into commonly used bundles. Technologies and tools are available as separate downloads for those wishing to get a specific component.
The content of the Autonomic Computing Toolkit is too large and varied to be downloaded as a whole; therefore, the large amount of content has been broken down into a handful of easy-to-obtain bundles. These bundles help you get to the right content without having to know all of the specifics of the Autonomic Computing Toolkit and avoid downloading more content than you want or need. The bundles are available on the autonomic computing Web site at:
www.ibm.com/developerworks/autonomic/
The Autonomic Computing Toolkit bundles use the solution installation and deployment technologies along with InstallShield for Solution Install (ISSI) to provide packaging and installation of the bundles.
The following bundles are available in the Autonomic Computing Toolkit:
The following sections describe each of the available bundles in detail.
This bundle contains all the pertinent autonomic computing references, documentation, and tutorials that describe the Autonomic Computing Toolkit. It is a good starting point for those who want to find out more about autonomic computing and the Autonomic Computing Toolkit. Much of the content provided here is available in HTML-viewable format on the Autonomic Computing Toolkit Web site at:
www.ibm.com/developerworks/autonomic/
This bundle includes documentation only.
The Adobe reader is a prerequisite. It can be obtained from the Adobe Website at http://www.adobe.com/products/acrobat/readstep2.html.
This documentation describes the Autonomic Computing Toolkit as a whole.
This bundle contains the AME component. For more information on AME, see Autonomic management engine (AME).
This bundle includes:
This bundle has no prerequisites.
The following bundles are related:
This bundle contains the Integrated Solutions Console component. For more information on the Integrated Solutions Console, see Integrated Solutions Console.
This bundle includes:
The Integrated Solutions Console requires that your system have a Domain Name System (DNS) entry and that the host name can be resolved. If your system does not have a DNS entry, you can update the following line in the host's file:
127.0.0.1 your.server.name
where your.server.name is the name of your server if you do not have a DNS entry for your server.
The Problem Determination Scenario bundle (see Problem Determination scenario) shows how an Integrated Solutions Console plug-in can be created and used to administer an actual self-healing solution. The Solution Installation and Deployment Samples scenario bundle uses the sameIntegrated Solutions Console plug-in to administer sample features of self-configuring.
This bundle contains the Generic Log Adapter and the Log and Trace Analyzer tooling plug-in. For more information on the Generic Log Adapter, see Generic log adapter (GLA) for autonomic computing. For more information on the Log and Trace Analyzer tooling plug-in, see Log and Trace Analyzer (LTA).The GLA/LTA plug-ins require Eclipse
This bundle includes:
The GLA/LTA plug-ins require Eclipse 3.0 or later. Eclipse 3.0.1 can be obtained from the "Eclipse tooling" bundle.
The Problem Determination Scenario bundle shows how the Generic Log Adapter is used in a real-time autonomic solution (see Problem Determination scenario). The Generic Log Adapter Runtime and Rule Sets bundle.
This bundle contains the runtime needed to produce Common Base Events from log files based on user-written rules. Predefined rule sets are also provided for various IBM products. For more information on the Generic Log Adapter, see Generic log adapter (GLA) for autonomic computing
This bundle includes:
None.
The Problem Determination Scenario bundle shows how the Generic Log Adapter runtime is used in a real-time autonomic solution (see Problem Determination scenario) The Generic Log Adapter and Log Trace Analyzer Tooling bundle contains the Adapter Configuration Editor for creating rules to be used by the runtime.
This bundle contains the Remote Agent Controller (RAC) for multiple platforms to allow processing of remote log files using the Log Trace Analyzer tool. For more information on RAC, see Agent controller
The RAC is packaged as a single zip file. The RAC will be provided in the Autonomic Computing Toolkit as a single package which includes the following run times:
None
This bundle can be used with the Generic Log Adapter and the Log Trace Analyzer Tooling bundle (See Generic Log Adapter (GLA) and Log and Trace Analyzer (LTA) Tooling plug-ins)
This bundle contains the base Eclipse needed to run the Autonomic Computing Toolkit tooling plug-ins.
For information on Eclipse, see Eclipse
This bundle includes:
None.
The GLA/LTA tooling bundle (page Generic Log Adapter (GLA) and Log and Trace Analyzer (LTA) Tooling plug-ins), and the RMB bundle (page Resource Model Builder) are provided as plug-ins to an Eclipse base. If the user does not already have an Eclipse 3.0 or later environment installed, then this bundle provides the necessary base tooling support.
This bundle contains the Resource Model Builder (RMB) component plug-in. For more information on RMB and AME resource models see Autonomic management engine (AME)
This bundle includes:
This RMB plug-in requires Eclipse 3.0 or later. Eclipse 3.0.1 can be obtained from the "eclipse tooling" bundle.
The following bundles are related:
This bundle contains the Problem Determination scenario. For more information on the Problem Determination scenario, see Problem Determination scenario.
This bundle includes:
You must have the following components installed in order to use this bundle:
This bundle uses technologies contained in the following bundles:
This bundle contains the Solution Installation and Deployment scenario using ISSI. For more information on this scenario, see Automated installation scenarios.
This bundle includes:
None.
The following bundles are related:
This bundle contains the Solution Installation and Deployment scenario using InstallAnywhere. For more information on this scenario, see Automated installation scenarios.
This bundle includes:
None.
The following bundles are related:
Solution Installation and Deployment samples are related samples of solution installation features that are demonstrated and controlled using the AC Toolkit Integrated Solutions Console component plug-in.
This bundle includes:
Integrated Solution Console bundle
The following bundles are related:
When you are ready to try a tool, technology, or scenario from the Autonomic Computing Toolkit, you will need to decide which bundle you need, ensure that you have the required prerequisites, and then download the code from the developerWorks Web site at:
www.ibm.com/developerworks/autonomic/
To download the code, perform the following steps:
If you have any trouble with this process, post a question to the support forum.
Before you use the forum for the first time, you will need to create a user ID and password, but you will be able to reuse this ID each time you post to the forum.
This section describes installing the Autonomic Computing Toolkit bundles.
The Autonomic Computing Toolkit bundles are generally installed the same way for consistency. However, some bundles contain single components, whereas others contain multiple components, which means the installations are presented differently.
Bundles are executable files utilizing the solution, installation and deployment technologies that perform their own installation; this helps create consistent installations and minimizes user error.
Registration information is logged into the Solution Installation and Deployment registry when you install the bundles. This registry information is then used for future installations and dependency checking.
The following items are required to run the Autonomic Computing Toolkit:
| Component | Disk space required | Temp space required |
|---|---|---|
| Agent Controller | 314 MB | NA |
| Autonomic Management Engine | 20 MB | 130 MB |
| Eclipse tooling | 93 MB | 130 MB |
| Generic Log Adapter/Log Trace Analyzer tooling plug-ins | 52 MB | NA |
| Generic Log Adapter Runtime/Rule Sets | 23 MB | 130 MB |
| Integrated Solutions Console (win, linux, aix, solaris) | 1.48 GB | 727 MB |
| Integrated Solutions Console (OS 400) | 835 MB | 28 MB |
| Problem Determination scenario | 25 MB | 130 MB |
| Resource Model Builder plug-in | 16 MB | NA |
| Solution Installation and Deployment Samples scenario | 7 MB | 130 MB |
| Solution Installation and Deployment scenario using InstallAnywhere | 2 MB | 130 MB |
| Solution Installation and Deployment scenario using ISSI | 8 MB | 130 MB |
For information on Supported platforms and the Application server, go to www.ibm.com/developerworks/autonomic/table.html .
To install an Autonomic Computing Toolkit bundle, perform the following steps:
To uninstall an Autonomic Computing Toolkit bundle, perform the following steps:
On OS400 only command line installation is supported. The installer for this platform is a JAR file. Follow the instructions below for installation and uninstallation.
Java --jar <jar file name>
Follow the instructions.Java --jar <install-location>/_uninst/uninstalljar
Follow the instructions.Eclipse is included as part of the Autonomic Computing Toolkit. Table 2 shows which tools can be used with the autonomic computing tool and which require Eclipse support.
| Autonomic computing tool | GLA Configuration Editor and LTA plug-in | RMB plug-in | Integrated Solutions Console Toolkit | |
| Eclipse | Eclipse V3.0.1 (included) | WebSphere Portal Toolkit 5.0 (not included) | ||
| WebSphere Studio Application Developer (not included) or WebSphere Studio Site Developer (not included) | ||||
This section describes how to install Integrated Solutions Console.
Before you begin the Integrated Solutions Console installation process, perform the following steps:
Integrated Solutions Console assumes that the host system is using a static IP address instead of a dynamically assigned IP address. Therefore, configure your machine using static a IP address. If you are installing Integrated Solutions Console for your use only and no other users will need to access this Integrated Solutions Console installation, you must configure your system so that the IP loopback port is mapped to the fully-qualified host name.
To enable mapping, add the following lines to your hosts file. For example, on Windows the hosts file is located in C:\WINNT\system32\drivers\etc\host:
127.0.0.1 localhost 127.0.0.1 your.server.name
To install the Integrated Solutions Console, perform the following steps:
.
To uninstall Integrated Solutions Console, perform the following steps:
After a successful installation, the Integrated Solutions Console installation program automatically starts Integrated Solutions Console and its help system. When the machine is rebooted, the ISC_Portal server is in the stop state. The Integrated Solutions Console does not function if the ISC_Portal server is not running.
To start Integrated Solutions Console and its help system:
For Windows:
To stop Integrated Solutions Console and its help system:
The Integrated Solutions Console installation program provides an option to install the Integrated Solutions Console plug-in for WebSphere Studio Application Version 5.1.1 or WebSphere Studio Site Developer Version 5.1.1. The Integrated Solutions Console plug-in includes a wizard and editor that make it easy to create a component .xml file and add that file to an existing portlet application project. The plugins and the above software is not required if you have just want to operate the Scenario.
Before installing the plug in, first install WebSphere Studio Application Developer Version 5.1.1 from http://www.software.ibm.com/wsdd/zones/studio/ or WebSphere Studio Site Developer Version 5.1.1 from http://www14.software.ibm.com/webapp/download/product.jsp?cat=swdev=SPAT-524G3S and WebSphere Portal Toolkit 5.0 from https://www6.software.ibm.com/dl/portaltk/portaltk-i?S_PKG=dlportal50ww.
The plug in provides help documentation that describes how to use the wizard and editor, and how to manually perform some tasks that the plug in does not automate. To view the documentation, click Help > Help Contents on the toolbar for WebSphere Studio Application Developer. The help displays in a separate window. Click Integrated Solutions Console documentation in the left navigation tree. Then click the subtopic you want to view.
To verify that the Integrated Solutions Console install was successful:
Perform the following check if problems occur while installing the Integrated Solutions console:
The information below lists the installation log files, describes the file content, and recommends when to check the file for information that might assist in troubleshooting installation problems.
The file path of the installation logs is: temp, where temp is the value of the operating system variable $TEMP or %TEMP%. Depending on the operating system, these files might not be saved after a system is shutdown.
The following files also need to be protected, because they contain passwords that are not encrypted.
If the attempt to uninstall Integrated Solutions Console is not successful, try the following steps:
The Autonomic Computing Toolkit includes an abundance of documentation. Most of the publications and all of the tutorials are available on the Autonomic Computing Toolkit Web site at:
www.ibm.com/developerWorks/autonomic/
The recommended document flow is shown in Figure 20. The documentation will be most helpful if you begin with the Autonomic Computing Toolkit User's Guide (this guide) and work your way through the publications as shown below.
.
The following information is available on autonomic computing:
The following information is available on the Autonomic Computing Toolkit:
