Maximo : MAS Understanding the Role of Customization Archives in IBM Maximo Application Suite Upgrades

 Introduction

As organizations transition from IBM Maximo EAM 7.6.1.2 to the cloud-native Maximo Application Suite (MAS), managing customizations becomes critical for seamless deployment. This article explores the technical mechanics of the Customization Archive—a pivotal artifact in the MAS upgrade workflow—detailing its structure, integration with OpenShift operators, validation protocols, and best practices for ensuring upgrade fidelity.

---

1. The Customization Archive: Purpose and Deployment Context

When Is It Required?

The Customization Archive is essential only if migrating a customized Maximo instance. Unmodified deployments bypass this component entirely.

Integration with the MAS Manage Operator

During the deployment of MAS Manage (the evolution of Maximo EAM), the OpenShift Manage Operator initiates a Docker build process that:

1. Pulls base container images from the IBM Entitled Registry.

2. Fetches the Customization Archive (if specified) from a customer-hosted repository (HTTP/S, FTP, or SFTP).

3. Overlays industry solutions/add-ons and the extracted archive onto the Manage base image.

4. Validates dependencies against the MAS compatibility matrix.

5. Generates runnable container images (Admin, UI, Cron, BIRT, and All workloads) stored in the cluster’s Image Registry.

This process is triggered via a Custom Resource (CR) definition, where administrators configure:

• Application version/replica counts

• Database connectivity

• Workload types

• Path to the Customization Archive

---

2. Archive Composition: Technical Scope

The archive is a .zip file containing only modifications outside standard Maximo. A representative structure includes:

Component Type	Example Paths
Java Classes	/applications/maximo/businessobjects/classes/cust/...
Configuration Files	product.xml, a_customer.xml
Database Scripts	/tools/maximo/en/cust/V7612_01.dbc
Servlets	Custom MyPingServlet.class under OSLC providers
Web Deployment	Liberty web.xml for MEA, UI, or All workloads
Third-Party Libs	JARs in /applications/maximo/lib/
JSP Overrides	Custom .jsp files in UI components

Key Consideration: Omit unmodified OOTB assets. The archive should exclusively contain delta customizations.

---

3. Implementation Workflow

Step 1: Compile the Archive

• Collate all custom files (classes, scripts, configs) into a .zip preserving directory hierarchy.

• Verify against a dependency matrix to prevent conflicts with MAS core.

Step 2: Host the Archive

Upload to a repository accessible via curl/wget (e.g., GitHub, S3, or internal artifact store):

https://<repository-host>/path/customizationarchive.zip  

Credentials (if required) are injected during the OpenShift build via the CR.

Step 3: Deploy via Manage CR

Specify the archive URL in the Custom Resource during Manage activation:

yaml

apiVersion: manage.mas.ibm.com/v1  
kind: ManageApp  
metadata:  
  name: mas-manage  
spec:  
  customizationArchive:  
    url: "https://github.com/myorg/repo/raw/main/customizationarchive.zip"  
    credentialsSecretRef: repo-credentials # Optional secret for auth  

---

4. Post-Deployment Validation

Post-installation, rigorously verify customizations:

1. Functional Testing: Execute test cases covering all modified workflows.

2. Log Analysis: Check container logs for archive extraction errors.

3. Artifact Verification: Confirm files exist in expected container paths:

   bash

   oc exec <pod-name> -- ls /opt/ibm/maximo/applications/maximo/businessobjects/classes/cust  

4. Compatibility Testing: Validate custom logic against MAS APIs and dependencies.

Critical: Some 7.6.1.2 customizations may require refactoring for cloud-native operation due to architectural shifts (e.g., stateless workloads, Liberty server constraints).

---

5. Strategic Recommendations

1. Pre-Upgrade Audit

   • Inventory all customizations; discard obsolete/duplicate artifacts.

   • Analyze compatibility with MAS 8.x (e.g., deprecated APIs, UI framework changes).

2. Archive Minimalism
   Exclude non-essential files to reduce build complexity and failure points.

3. Continuous Integration
   Host the archive in a version-controlled repo linked to CI/CD pipelines for traceability.

4. Fallback Testing
   Maintain a rollback path to the source 7.6.1.2 instance during validation.

---

Conclusion

The Customization Archive is the conduit for lifting mission-critical customizations into MAS. Its precise construction—coupled with dependency validation and exhaustive testing—determines upgrade success. By adhering to structured compilation practices and leveraging OpenShift’s GitOps capabilities, enterprises can achieve deterministic MAS deployments while mitigating technical debt.

For further guidance, refer to IBM’s MAS Upgrade Documentation or consult IBM’s migration playbooks.

---

Maximo : MAS AppPoints License Model - quick view

 Here is broad and quick overview of Maximo Application suite AppPoint based licensing mode.

MAXIMO : WebSphere Automatically restart MXServer post Node Restart

 Here are simple steps outlined in below screenshot easily configured through WebSphere Admin console user interface 

MAXIMO: Monitoring License Usage in IBM Maximo: An Overview of License Usage Monitor Application

 Managing licenses in an enterprise-scale software like IBM Maximo can be a challenging task, especially when dealing with multiple users, modules, and license types. Accurate tracking of license usage is critical for compliance, cost optimization, and ensuring that your organization is utilizing the right number of licenses.

IBM Maximo provides a powerful solution to manage license compliance and usage through the License Usage Monitor (LUM) application. This application helps administrators track the number of active users, analyze usage trends, and avoid potential overuse, which can lead to costly penalties. In this blog, we’ll explore how you can leverage the License Usage Monitor application in IBM Maximo to streamline your license management process.

1. What is the License Usage Monitor Application?

The License Usage Monitor is a feature in Maximo that allows administrators to monitor and control the usage of licenses in real-time. It provides insights into:

• The number of concurrent users utilizing Maximo at any point.
• The types of licenses being used (e.g., concurrent vs. authorized user licenses).
• The user activity and history.
• License compliance reports.

With this tool, organizations can ensure that they are within the boundaries of their licensing agreements and make data-driven decisions about their licensing needs.

2. Key Features of License Usage Monitor

Here are the key features and functionalities that the LUM application offers:

a. Real-Time License Tracking

LUM provides an overview of the real-time license usage across all users in the Maximo system. You can view the total number of active users, the modules they are accessing, and the types of licenses in use.

Screenshot: Main dashboard displaying active licenses and users.

b. User and License Type Breakdown

The application gives you the ability to see detailed license usage per user and per license type (e.g., whether they are using a concurrent user license, an authorized user license, etc.). This breakdown helps in identifying how different types of licenses are being used.

Screenshot: List of users and their respective license types in use.

c. Historical Usage Data

LUM keeps track of historical data that allows you to analyze usage trends over time. You can generate reports showing license usage patterns by day, week, or month. These insights are useful for making forecasts and ensuring that your organization has the right number of licenses.

Screenshot: A graph showing the historical license usage trends.

d. Alerts for License Thresholds

To prevent over-utilization of licenses, you can configure alerts in LUM to notify administrators when the usage approaches the maximum limit of available licenses. This feature can help you avoid potential license overages and compliance issues.

e. Audit and Compliance Reporting

LUM offers built-in reports that can be used for internal audits or external reviews, ensuring that your organization complies with its licensing agreements. These reports can be easily generated and shared with stakeholders or auditors.

Screenshot: Example of a compliance report generated from License Usage Monitor.

f. User Session Tracking

For concurrent user licenses, LUM tracks the length of each user’s session. This data helps administrators identify heavy users and ensure optimal utilization of concurrent licenses, which can have an impact on costs.

3. How to Use the License Usage Monitor Application?

Step 1: Navigating to the License Usage Monitor Application

Once you have logged into IBM Maximo as an administrator, you can navigate to the License Usage Monitor application by following these steps:

• Go to the Administration module in the Maximo navigation menu.
• Select License Usage Monitor from the list of available applications.

Step 2: Monitoring License Usage

In the main dashboard of the License Usage Monitor application, you will see a real-time overview of active users and licenses. This dashboard displays the current license usage and provides detailed statistics about which users are using Maximo and the modules they are accessing.

Screenshot: Real-time license usage overview in the dashboard.

Step 3: Generating Usage Reports

You can generate detailed reports about license usage for a specific time range. These reports can include breakdowns by user, license type, or module. You can also export these reports for further analysis or for sharing with external auditors.

Step 4: Configuring Alerts

To prevent overuse of licenses, you can set up alerts to be notified when the license usage reaches a certain threshold. This proactive measure ensures that you avoid going over your license allotment.

4. Best Practices for Managing License Usage

• Regularly Review License Usage: It's important to monitor your license usage regularly to ensure compliance. LUM offers a simple and effective way to do this with its real-time and historical tracking features.
• Set Up Alerts: Always configure alerts when nearing your license limits. This will allow you to take action before non-compliance issues arise.
• Forecast Future Needs: Use historical data from LUM to analyze trends and forecast your future licensing needs. This will help you make informed decisions when negotiating license renewals or expansions.
• Clean Up Unused Licenses: Make sure to regularly review and deactivate accounts that are no longer in use to optimize your license consumption.

5. Conclusion

The License Usage Monitor in IBM Maximo is a crucial tool for managing license compliance and usage in a large enterprise environment. By providing real-time tracking, reporting capabilities, and alerts, LUM enables administrators to ensure that they are using the correct number of licenses efficiently and effectively.

With this tool, organizations can avoid unnecessary penalties, optimize their license usage, and ensure compliance with vendor agreements. Incorporating regular reviews of license usage into your IT asset management strategy is a best practice that will pay dividends over time.

If you haven't yet explored the License Usage Monitor application, now is the time to start. By leveraging its capabilities, you can take control of your Maximo licenses and stay ahead of compliance challenges.

Installing Maximo 7.6 on Redhat Linux

 

Installing Maximo 7.6 on Redhat Linux 

Developerworks links:
Installing Maximo 7.6 on Redhat Linux 6.6 (1 of 3)
Installing Maximo 7.6 on Redhat Linux 6.6 (2 of 3)
Installing Maximo 7.6 on Redhat Linux 6.6 (3 of 3)

MAS : Maximo Application Suite Education Roadmap and available trainings for BP's

 Here is PDF with details roadmap having cost and no cast self paced IBM trainings for MAS functional and technical education roadmap.

MAS_Technical_Courses_IBM

MAXIMO : Query Manager App

 

Streamline Your Maximo Queries with the Custom Query Manager App

IBM Maximo offers powerful querying capabilities, but managing user-created queries can be a real headache. There's no centralized way to edit or transfer ownership of saved queries. This can lead to several issues, especially in large organizations:

• Orphaned Queries: When users leave the organization, their queries become orphaned. Updating details from the backend becomes difficult, potentially causing errors or improper loading of start centers that rely on those queries.
• Inefficient Management: Lack of a central location for managing queries makes it cumbersome to track ownership, edit details, or redistribute queries as needed. This can lead to confusion and wasted time for both users and administrators.
• Limited Collaboration: Sharing or collaborating on queries can be challenging without a clear understanding of ownership and access rights.

Introducing the Query Manager App

This blog post introduces a custom Maximo application called "Query Manager" that simplifies query management for both users and administrators. Built as a Power Application on the Query object, Query Manager provides a user-friendly interface for:

• Viewing Query Details: Users can access basic information about a saved query, including its name, description, and owner.
• Editing Queries: Users can easily modify their own saved queries directly within the application.
• Transferring Ownership: Administrators can take ownership of queries created by other users, ensuring proper maintenance and access control.

Enhanced Visibility with Start Center Usage Table

Query Manager goes beyond basic query details. It includes a table that displays a list of start centers where the selected query is currently used. This allows users to quickly understand the impact of a query and its potential impact on reports and workflows.

Here is how it look in action:

Benefits of Query Manager

• Improved User Experience: Streamlined editing and ownership transfer capabilities empower users to manage their queries effectively.
• Enhanced Control for Administrators: Administrators gain the ability to take ownership of orphaned queries or redistribute them as needed.
• Increased Visibility: The start center usage table provides valuable insights into query utilization, aiding in decision-making and optimization.
• Reduced Risk of Errors: By facilitating ownership transfer, Query Manager eliminates the need for potentially risky backend updates when users leave the organization.

Building the Query Manager App

Developing the Query Manager application requires familiarity with Maximo customization tools. Here's a high-level overview of the steps involved:

1. Create a New Power Application: Design the application interface using Maximo's Application Designer. Include sections for query details, edit and ownership buttons, and the start center usage table.
2. Develop Custom Logic: Create business logic to handle user actions such as edit query, transfer ownership, and retrieve start center usage data for the selected query.
3. Implement Security: Ensure proper access controls for edit and ownership functionalities, restricting them to authorized users or roles.

Here are my configuration and code components ( V 7.6.1.3)
1. Application XML :               

2. Automation Scripts

3. Sigoptions : 

4. Application Authorization : 

Here you can access all these artifacts and set up this application in your maximo instance within 10 minutes.

Query Manager by Prashant Bavane

Conclusion

The Query Manager application effectively addresses a common challenge in Maximo: managing user-created queries. By providing a centralized platform for editing, transferring ownership, and visualizing start center usage, Query Manager empowers users and administrators to leverage Maximo's querying capabilities more efficiently.

Next Steps

• Explore Maximo's Power Applications and customization options to build your own Query Manager app.
• Consider integrating additional features like search functionality or query version control.

With Query Manager, you can take control of your Maximo queries, enhancing user experience, streamlining management, and reducing the risk of errors associated with orphaned queries.