A Practical Guide to the IBM Autonomic Computing Toolkit

Book description

This IBM Redbooks publication provides practical information related to using the IBM Autonomic Computing Toolkit. Using this toolkit, software developers can provide facilities to enable applications or other system components to participate in an autonomic environment.

IBM provides the Autonomic Computing Toolkit to assist software developers in enabling components, products, and solutions to become autonomic. The toolkit also provides the base for developers of management software to be able to manage entities that have been properly enabled. As with the technologies themselves, this toolkit will evolve as new capabilities and tools become available.

This book provides a view of the Autonomic Computing Toolkit as it exists today and describes how it can be used to enable autonomic capabilities. This book primarily focuses on the problem determination capabilities provided by the Autonomic Computing Toolkit. Other facilities, such as Solution Installation and Integrated Console support, to name two, will be covered in future books.

Please note that the additional material referenced in the text is not available from IBM.

Table of contents

  1. Figures
  2. Notices
    1. Trademarks
  3. Preface
    1. The team that wrote this redbook
    2. Become a published author
    3. Comments welcome
  4. Part 1: Introduction
    1. Chapter 1: Introduction to Autonomic Computing
      1. What is autonomic computing?
        1. Guiding principles
      2. Autonomic computing concepts (1/2)
      3. Autonomic computing concepts (2/2)
        1. Managed resources
        2. Autonomic manager
        3. Autonomic manager collaboration
        4. Autonomic manager knowledge
        5. Policies for autonomic managers
      4. Evolving to autonomic computing
        1. Architectural levels of maturity
      5. Value of autonomic computing
        1. Software vendors
        2. Enterprises
      6. Architectural overview (1/2)
      7. Architectural overview (2/2)
        1. Solution install
        2. Common systems administration
        3. Problem determination
        4. Autonomic monitoring
        5. Complex analysis
        6. Policy-based management
        7. Heterogeneous workload management
        8. Summary
    2. Chapter 2: Introduction to the IBM Autonomic Computing Toolkit
      1. Key component areas
      2. Autonomic Computing Toolkit technologies
      3. Summary
    3. Chapter 3: Steps to enable a managed resource
      1. Overview of a rudimentary control loop system
      2. Generating information or events (Steps 1 and 2)
      3. Sending events (Step 3)
      4. Control loop (Step 4)
      5. Management actions (Step 5)
      6. Summary
  5. Part 2: Tools and APIs
    1. Chapter 4: Common Base Events and touchpoints
      1. What is a Common Base Event?
      2. Common Base Event schema
        1. Example of a Common Base Event
      3. Generating Common Base Events
      4. Generating Common Base Events using APIs
        1. Create the Common Base Event
        2. Filling in the Common Base Event
        3. Using sendEvent() to send the Common Base Event
      5. Managed resource and manager touchpoints
        1. The interface IManagedResourceTouchpoint
        2. The interface IAutonomicManagerTouchpointSupport
      6. Summary
    2. Chapter 5: Generic Log Adapter and Log and Trace Analyzer
      1. Generic Log Adapter (1/4)
      2. Generic Log Adapter (2/4)
      3. Generic Log Adapter (3/4)
      4. Generic Log Adapter (4/4)
        1. Generic Log Adapter configuration file overview
        2. Creating the adapter configuration file
        3. Editing the adapter configuration file
        4. Testing the adapter configuration file
        5. Deploying and running the adapter configuration file
        6. Writing a custom outputter
      5. Log and Trace Analyzer (1/3)
      6. Log and Trace Analyzer (2/3)
      7. Log and Trace Analyzer (3/3)
        1. Adding the log file to Log and Trace Analyzer
        2. Analyze log events created by one product
        3. Correlate log events from different products
        4. Using the symptom database to analyze log files
      8. Summary
    3. Chapter 6: Resource models
      1. Introduction to resource models (1/2)
      2. Introduction to resource models (2/2)
      3. Designing an autonomic resource model
        1. Defining the ITSO_CBELog_Monitor resource model
      4. Implementing the ITSO_CBELog_Monitor resource model (1/11)
      5. Implementing the ITSO_CBELog_Monitor resource model (2/11)
      6. Implementing the ITSO_CBELog_Monitor resource model (3/11)
      7. Implementing the ITSO_CBELog_Monitor resource model (4/11)
      8. Implementing the ITSO_CBELog_Monitor resource model (5/11)
      9. Implementing the ITSO_CBELog_Monitor resource model (6/11)
      10. Implementing the ITSO_CBELog_Monitor resource model (7/11)
      11. Implementing the ITSO_CBELog_Monitor resource model (8/11)
      12. Implementing the ITSO_CBELog_Monitor resource model (9/11)
      13. Implementing the ITSO_CBELog_Monitor resource model (10/11)
      14. Implementing the ITSO_CBELog_Monitor resource model (11/11)
        1. Managed Object Format (MOF)
        2. Instrumentation Library Type (ILT) Java class
        3. Generating the resource model using Resource Model Builder
        4. Understanding and editing the decision tree JavaScript
      15. ITSO_CBESocket_Monitor resource model (1/7)
      16. ITSO_CBESocket_Monitor resource model (2/7)
      17. ITSO_CBESocket_Monitor resource model (3/7)
      18. ITSO_CBESocket_Monitor resource model (4/7)
      19. ITSO_CBESocket_Monitor resource model (5/7)
      20. ITSO_CBESocket_Monitor resource model (6/7)
      21. ITSO_CBESocket_Monitor resource model (7/7)
        1. Resource model design
        2. Parameters for ITSO_CBESocket_Monitor resource model
        3. Creating the ITSO_CBESocket_Monitor resource model
        4. Using the Resource Model Builder
      22. Contents of Resource Model Package
      23. Summary
    4. Chapter 7: Autonomic Management Engine
      1. Introduction to Autonomic Management Engine
      2. Writing an embedding application for AME (1/3)
      3. Writing an embedding application for AME (2/3)
      4. Writing an embedding application for AME (3/3)
        1. Designing the embedding application
        2. Building and launching the AME embedding application
      5. Simple Agent Reference Application (SARA)
      6. Advanced topics (1/3)
      7. Advanced topics (2/3)
      8. Advanced topics (3/3)
        1. Adding actions and events to resource models
        2. Setting up the configuration files and environment
      9. Summary
  6. Part 3: Samples
    1. Chapter 8: Application examples
      1. Sample application
      2. Maturity level 2 - Using GLA and LTA
      3. Maturity level 4 - Using GLA and AME (1/2)
      4. Maturity level 4 - Using GLA and AME (2/2)
      5. Generating Common Base Events directly (1/2)
      6. Generating Common Base Events directly (2/2)
      7. Adding sockets to communicate events to the autonomic manager
      8. Using a database to store received events
      9. Summary
  7. Part 4: Appendixes
    1. Appendix A: Regular expressions
      1. What is a regular expression?
      2. How they work
      3. Regular expressions: most commonly used matching characters
      4. Regular expression examples
    2. Appendix B: Additional material
      1. Locating the Web material
      2. Using the Web material
      3. System requirements for downloading the Web material
      4. How to use the Web material
  8. Related publications
    1. IBM Redbooks
    2. Other publications
    3. Online resources
    4. How to get IBM Redbooks
    5. Help from IBM
  9. Index (1/2)
  10. Index (2/2)
  11. Back cover

Product information

  • Title: A Practical Guide to the IBM Autonomic Computing Toolkit
  • Author(s): Bart Jacob, Richard Lanyon-Hogg, Devaprasad K Nadgir, Amr F Yassin
  • Release date: April 2004
  • Publisher(s): IBM Redbooks
  • ISBN: None