Level 10 · 15 levels · Builder · about 95 minutes
Level 10 — CI/CD/CT, and how mxR ships Maximo changes as work orders
By the end: Explain CI, continuous delivery, continuous deployment and continuous testing, say why a generic runner has to be taught Maximo, and walk a change through mxR: plan, approve, start, test, promote site by site, and recover from a failure with its code and runbook.
An mxR change work order goes WAPPR, APPR, INPRG and COMP on DEV, then the same work order and commit move to TEST and then PROD. Failure sends it to CAN with a failure code.
Lesson 1
CI, continuous delivery, continuous deployment and continuous testing
Four ideas sit behind every modern release process. They have similar names, so learn them exactly. The definitions below are AWS's, from its whitepaper on CI/CD, and they match how the industry uses the words.
| Term | Definition | What it changes for you |
|---|---|---|
| CI: continuous integration | "a software development practice where developers regularly merge their code changes into a central repository, after which automated builds and tests are run" | You merge small changes often, and a broken change is found in minutes, while you still remember writing it |
| CD: continuous delivery | "code changes are automatically built, tested, and prepared for production release" | Every passing change is ready to ship. A person decides when it goes live |
| CD: continuous deployment | "revisions are deployed to a production environment automatically without explicit approval from a developer" | Every passing change goes live on its own. It needs very strong tests |
| CT: continuous testing | Tests run at every stage, and a failing gate stops the change | Quality is checked all the way along, not once at the end |
Four lanes. CI: every commit is built and tested. Continuous delivery: every passing change waits ready, and a person presses release. Continuous deployment: every passing change goes live on its own. Continuous testing: tests run at every stage.
The difference between delivery and deployment is one human decision. In continuous delivery a person approves the release. In continuous deployment nobody does. Maximo teams almost always choose delivery for production, because a Maximo change can stop work for hundreds of people, and change boards want a named person to approve it inside an agreed window.
A pipeline is the ordered list of stages a change passes through. Each stage that can stop the change is called a gate. Fast checks go first, so a mistake is caught in seconds and never reaches a shared system.
- Commit
- Build
- Unit tests
- Deploy to DEV
- Integration and UI tests
- Approve
- Deploy to TEST, then PROD
- Smoke test
A typical pipeline, gate by gate
A change flows through build, unit tests, deploy to DEV, integration and UI tests, approval, deploy to TEST then PROD and a smoke test. Each stage turns green in turn.
The mistake: "We do CI": a pipeline exists, but people merge once a fortnight and the tests run overnight. Do this instead: CI is a habit, not a tool. Merge small changes at least daily, and keep the checks fast enough to run on every change.
Remember: Continuous delivery: always ready, a person presses release. Continuous deployment: it releases itself.
Lesson 2
Runners, and why they must be taught Maximo
A runner is the tool that actually executes a pipeline. GitHub Actions, Azure DevOps Pipelines, GitLab CI and Jenkins are the common ones. They trigger a run when you push, schedule runs, hold approval screens and keep logs. They do this for any software, which is their strength and their limit: none of them knows what a Maximo automation script, a presentation, a domain or a Migration Manager package is.
Tekton is the runner that lives inside Kubernetes and OpenShift, the platform MAS runs on. Its docs define four pieces. A Task "Defines a series of steps which launch specific build or delivery tools". A Pipeline "Defines a series of Tasks that accomplish a specific build or delivery goal". A TaskRun and a PipelineRun are single runs of a Task and a Pipeline. Because it runs on the same cluster as Manage, a Tekton task can reach the Manage routes and the ManageWorkspace.
Why does Maximo need special teaching? Because a Maximo release is made of different kinds of change, and each kind moves in its own way.
Four lanes: configuration moves in Migration Manager packages, database structure moves in DBC scripts run by updatedb, Java moves in a customisation archive and a rebuild, and data moves in data loads.
| Kind of change | How it reaches a Maximo site | How heavy |
|---|---|---|
| Configuration: domains, presentations, scripts, escalations | Through the REST API or Migration Manager packages, while Manage keeps running | Light: minutes |
| Server settings: JVM options, JMS, certificates | A change to the ManageWorkspace, then the pods restart | Medium: a restart |
| Java classes and database scripts (DBC) | A customisation archive, then a rebuild of the Manage image and a database update | Heavy: IBM notes the build can take up to two hours |
| Data | Data loads, covered in Level 13 | Depends on volume |
IBM's customisation archive guidelines explain the heavy lane. The archive is a zip that mirrors Maximo's own folders: class files under the code tree, database scripts under tools/maximo/en/cust/ next to an a_customer.xml file that carries a <dbversion>, and Liberty files under additional-server-files. "When the application is redeployed, the customized files override the files that are provided for the deployment," and "After deployment, the database update utility runs and applies your custom scripts." The cluster must be able to download the zip from its URL without a login.
A configuration file (the ManageWorkspace custom resource) says what should be running. The operator compares it with what is running and changes the pods until they match, then keeps watching.
Teaching a runner all of this means writing, per artefact type: the right API call, the right order, the activation step afterwards (a new workflow revision must be activated, a cron task reloaded), a preview before writing, and a test afterwards. Then keeping it current with every Manage release. That is the gap mxR fills.
| A generic runner on its own | The runner plus mxR |
|---|---|
|
|
Remember: Keep your runner. mxR runs inside Azure DevOps, GitHub Actions, GitLab CI, Jenkins or Tekton, anywhere with Node 22 and a route to Manage.
Lesson 3
mxR: every change is a work order
mxR is Assetize's command line tool for CI/CD/CT on Maximo Application Suite Manage. Its idea fits in one line from its own page: "Ship Maximo changes the way Maximo ships work." Every change is raised as a work order with Maximo's own statuses. A Maximo administrator already knows that language, so the release process needs no new vocabulary.
| Pipeline idea | mxR's Maximo noun | What it carries |
|---|---|---|
| A change set or release | Work order | WAPPR → APPR → INPRG → COMP → CLOSE, or CAN. The work type is the tier: HOT, RESTART or REBUILD |
| An environment | Site | DEV, TEST, PROD. One work order is worked on one site at a time |
| The pipeline and its tests | Job plan | An ordered list of tasks, each with On, Gate and Test switches, a time budget and app tags |
| A schedule | PM | Raises an inspection work order on a timetable: nightly drift, a weekly UI run |
| A failure | Failure code | One field on the work order, such as TEST/GATE or DEPLOY/CR-NOTREADY, with a runbook |
A work order status machine: WAPPR to APPR to INPRG to COMP to CLOSE, with WSCH and WMATL as side statuses and dashed arrows to CAN from WAPPR and APPR. A token moves along allowed arrows. Once the work order is in progress, an attempt to cancel it is refused and shakes red, and the allowed moves are listed: WAPPR, WMATL, COMP, CLOSE.
| Status | Reached by | What it means |
|---|---|---|
| WAPPR | mxr plan, or mxr promote plan | Raised from the Git diff, or from what differs between two sites, with the job plan for its tier |
| APPR | mxr approve | Approved, with the approver recorded. A site with no approval gate self-approves and says so |
| INPRG | mxr start | Deploy for the tier, then every task in the job plan |
| COMP | Every gated task passes | Done on this site. Promotion is mxr start again on the next site, with the same commit |
| CAN | mxr cancel --code | Cancelled with one failure code, and the recovery runbook printed with the details filled in |
Important: the statuses are Maximo's, but the records are not in Maximo. An mxR work order, job plan or PM lives in your Git repository and in the run record under .mxr/runs/<WO>/run.json. Git is the only source of truth: nothing is configured in a screen that is not a file in the repo. What is deployed where is written as annotations on the ManageWorkspace (mxr.io/git-sha, mxr.io/archive-sha, mxr.io/backup-ref, mxr.io/deployed-at). A site without one takes the commit of its last completed work order.
A real plan, captured on Manage 9.2.237 (host masked)
$ mxr plan --from 623ab66
WO1001 WAPPR HOT commit 1e3e793a6929
job plan: standard-hot (10 tasks on, 8 gated)
changed paths: 16
tier HOT because:
HOT hot/scripts/MXR_DEMO_HELLO.py (goes in through REST)
HOT hot/scripts/MXR_DEMO_HELLO.yaml (goes in through REST)
HOT jobplans/standard-hot.yaml (tests and job plans: nothing to deploy, the job plan picks it up)
...
next: mxr start WO1001 --site DEVAn mxR change work order goes WAPPR, APPR, INPRG and COMP on DEV, then the same work order and commit move to TEST and then PROD. Failure sends it to CAN with a failure code.
The mistake: Thinking mxR creates WORKORDER records inside Manage to track releases. Do this instead: mxR borrows the statuses, not the table. Its work orders live in Git and run.json. The only records its tests create are on the test site, and they are cancelled or closed afterwards.
Lesson 4
The path rule: HOT, RESTART or REBUILD
Before mxR deploys anything it decides how heavy the change is. It uses one rule, and nothing else: the paths of the files that changed. The whole classification is git diff <deployed-sha>..HEAD --name-only. Each path falls into one of three tiers, and the highest tier wins. The plan prints the reason for every path, so nobody has to guess.
| Paths that changed | Tier | What happens | What it needs |
|---|---|---|---|
| hot/**, tests/**, jobplans/** | HOT | Preview every item, apply it in a fixed order through REST and MXR.AGENT, record each item in run.json, run the job plan. Minutes | The API key |
| Any other key in sites/*.yaml: the cr: overlay (server bundles, JVM options, JMS, imported certificates, persistent volumes) | RESTART | Merge the overlay into the ManageWorkspace spec and wait for Ready within the restart timeout | Cluster access |
| archive/**, or the site-file keys components, languages, buildTag, archives | REBUILD | Build <name>-<gitsha>.zip, upload it, check the cluster can reach it, patch the ManageWorkspace, wait for pods Ready, whoami answering and maxinst exited 0 | Cluster, bucket, admin image |
Changed file paths drop into three bins: hot/ and tests/ go to HOT, site file settings go to RESTART, archive/ and build settings go to REBUILD. REBUILD carries a backup reference and a window.
A site file is read at both commits, so only the keys that moved count. Changing the number of replicas is a RESTART. Changing buildTag is a REBUILD. Files under tests/ and jobplans/ deploy nothing: the job plan picks them up the next time it runs.
A HOT deploy applies items in one hard-coded order, because Maximo artefacts depend on each other. A script cannot attach to a launch point on an object structure that does not exist yet.
- Live-refresh system properties
- Domains, then object structures, endpoints, external systems, channels, integration controls, queues and JMS sequential consumers
- Conditions, then scripts with their launch points
- Presentations (application XML, lookups, library, menus, signature options), then security groups, then start centres
- Roles, actions, communication templates, calendars, person groups, then workflows (new revision, activate), escalations and cron tasks (activate, reload)
- Report designs and a report cache refresh, translations, Migration Manager packages
- MAF app definitions
Every item is previewed first: create, update or unchanged. A guard that trips (for example a domain value that records may still use) blocks the whole push. Before writing, mxR exports the live copy of every object it is about to touch into the run folder, so there is always a way back.
A REBUILD is the heavy lane from the last lesson, done carefully. Java under archive/<name>/java builds with Maven against the jars from the admin image. DBC files are checked: well-formed XML, a <sql target> for db2, oracle and sqlserver in every freeform statement, and a bumped <dbversion> in a_customer.xml whenever any .dbc changed, because updatedb keys on dbversion. The zip is deterministic, carries its SHA-256, and the ManageWorkspace gets its URL only after a short job inside the cluster has fetched its headers. "Ready" means three things: the Ready condition, every server bundle pod ready, and whoami answering; after a rebuild, also maxinst exited 0.
Changed file paths drop into three bins: hot/ and tests/ go to HOT, site file settings go to RESTART, archive/ and build settings go to REBUILD. REBUILD carries a backup reference and a window.
The mistake: Putting a Java class under hot/ to make it "deploy faster". Do this instead: The path rule is the contract. Java lives under archive/ and goes through a REBUILD, behind a backup reference, a window and an approval. A wrong folder is a wrong deploy.
Remember: One rule, three folders, and the reason printed for every path. That is why an administrator can trust the tier.
Lesson 5
One key, one script: init, doctor and MXR.AGENT
mxR needs one secret per site: an API key, read from an environment variable such as MXR_DEV_APIKEY. It never goes in the repo, the run record or any YAML file. Manage's own security decides what that key may do. There is no extra user, group or property to create.
Put it in your Maximo
npm install -g https://assetize.com.au/mxr/releases/v0.7.1/mxr-0.7.1.tgz # Node 22 LTS (20 still runs)
read -rs MXR_DEV_APIKEY && export MXR_DEV_APIKEY # paste the key: kept out of shell history
mxr init --site DEV --url https://<host>/maximo # mxr.yaml, sites/DEV.yaml and four job plans
mxr doctor # the key, the agent, the grants, the test site
mxr export --all && git add -A && git commit -m "mxr bootstrap"init writes mxr.yaml, the site file and four job plans: standard-hot, full-rebuild, drift and weekly-ui. doctor then proves the setup line by line, pass or fail, with the fix on every line: the key answers whoami, MXR.AGENT is installed or updated, the key's groups and Automation Scripts grants are enough, and one work order is created and cancelled on the test site. export pulls the live artefacts into hot/ with stable names and sorted keys, so from then on, drift is just git diff.
Some things Manage has no ready-made API for: importing a presentation, running a cron task now, compiling a Jython script on the server's own interpreter. mxR adds exactly one Jython automation script to each site, MXR.AGENT, installed through the Automation Scripts object structure with the same key. You call it over REST, the same way any script endpoint is called (IBM's REST docs show scripts invoked by name under /oslc/script/<name>):
One endpoint, many actions
POST /maximo/api/script/MXR.AGENT?action=script.compile| Actions | What they do |
|---|---|
| whoami.extended | The calling user and groups, bundle, database platform, MAXUPG build, Java version, admin mode |
| script.compile | Compile a Jython source on the site's own interpreter and return the error with its line, so lint fails the way Manage would |
| mbo.query, mbo.upsert | Read tables with no object structure (CRONTASKHISTORY, MAXINTMSGTRK, WFINSTANCE), and write typed records to hot artefact tables only |
| migmgr.list, migmgr.preview, migmgr.deploy | List packages, compare a change package before a push, deploy it |
| presentation.export, presentation.import | Read and write an application presentation and refresh the UI cache |
| cron.runNow, cron.reload, workflow.initiate, workflow.activate, ... | The activation step each artefact type needs after it is written |
Screens, the REST API and integrations all send changes through the MBO business rules layer, which checks them before they reach the database. A direct SQL arrow that tries to skip the rules is blocked with a red cross.
The agent is deliberately small and fenced. It runs as the caller, so the key's security group is the first layer and its own allowlist the second. It reads only hot artefact tables and the history tables the tests check, writes only to hot artefact tables, and leaves MAXUSER, APIKEYTOKEN, PASSWORDHISTORY, LOGINTRACKING, MAXSESSION, USERPASSWORD, the MAXADMIN group and every security property alone. Every call writes one audit line to the Manage log. It is plain Jython 2 with no standard-library imports, so it runs on the interpreter Manage ships.
The mistake: Pasting the API key into sites/DEV.yaml so the pipeline can find it. Do this instead: Keys live only in environment variables: MXR_<SITE>_APIKEY on your machine, or an OpenShift Secret per site mounted into the Tekton task. The repo stays free of secrets.
Lesson 6
Job plans: the board, the tests, golden screens and virtual records
A job plan is the pipeline and its tests, as data. It is a YAML file in jobplans/, one task per line, in order. Each task has On (run it), Gate (a failure stops the plan), Test (run its built-in test), a budget (a wall-clock limit: overrun fails) and app tags for UI journeys. mxR has 18 task types. The default plan for a HOT change is standard-hot.
A board of task cards in order: lint, DBC, Migration Manager preview, deploy, smoke, API, script tests, cron, MIF, UI journeys, golden screens and drift. Each card has On, Gate and Test switches. Dragging a card into a site column adds it.
| Task | Default | What it checks |
|---|---|---|
| lint | on · gate | Jython compiled on the site through MXR.AGENT; JavaScript parsed |
| dbc | on · gate | Well-formed XML, one <sql target> per database platform, dbversion bumped |
| migmgr | on · gate | Migration Manager package compare and per-item preview, read-only; conflicts block |
| deploy | on · gate | The deploy for the tier |
| smoke | on · gate · 5m | whoami.extended through the agent, bundle pods Ready, maxinst exit after a rebuild |
| api | on · gate · 10m | Playwright request tests on the test org and site; records are cancelled or closed |
| scripts-fn | on · gate · 5m | Calls each script endpoint with its sidecar tests, and fires a launch point with an assertion |
| cron | on · 5m | MXR.AGENT cron.runNow, then reads CRONTASKHISTORY |
| mif | on · gate · 8m | Inbound POST to /meaweb/es, then MAXINTMSGTRK and MAXINTERRORMSG; outbound to an in-cluster WireMock |
| ui | on · gate · 15m | Playwright journeys in Manage classic, filtered by app tags such as @WOTRACK |
| golden | on · gate · 10m | Every screen the push touched still opens with its title, control types, toolbar, tabs and Select Action entries |
| drift | on, report-only | Export and diff: what changed on the site outside Git |
A Maximo administrator composes job plans on the board. mxr ui serves one static page on localhost: task cards on the left, three site columns, drag to add or reorder, flip a gate, save. Saving commits the YAML file through the GitHub or GitLab API with your own token, so Git gives history, review and rollback for free. The next push raises a work order with the new plan.
Golden screens are mxR's regression net for the user interface. mxr export --golden opens every classic application the key's user may read and records each one's title, control types, toolbar actions, tabs and Select Action entries in tests/golden/<SITE>.json. On a Maximo for Aviation lab that was 286 screens at about 1.6 seconds each, all 286 checked again in 8 minutes 15 seconds. With --deep it also records each screen's journeys: More Search Fields, the saved queries, and the first record with every tab and sub-tab. On that lab: 287 screens, 894 generated tests, replayed by one weekly work order in about 50 minutes. The baseline is per site, because an add-on renames applications: Aviation calls Assets "Equipment".
A board of task cards in order: lint, DBC, Migration Manager preview, deploy, smoke, API, script tests, cron, MIF, UI journeys, golden screens and drift. Each card has On, Gate and Test switches. Dragging a card into a site column adds it.
Some sites must stay free of test data. One word in the site file switches to virtual records: test: { records: virtual }. MXR.AGENT then adds a work order, sets its values, runs Manage's own validation (database defaults, field classes, required fields) and discards it, so nothing reaches the database. The journeys that would create records switch themselves off, the read-only journeys still run, and the result names what was skipped.
An inspection with virtual records (real output, host masked)
$ mxr inspect --jobplan virtual-check
WO1005 INSPECT → DEV (virtual-check)
✓ smoke pass whoami.extended ok (MXINTADM on Manage 9.2.237 (db2, bundle all))
✓ api pass virtual work order validates on BEDFORD (would be 1294, nothing saved); 1 passed, 1 skipped
✓ scripts-fn pass 1 script test(s) passed
✓ ui pass 1 passed
✓ WO1005 COMPAn inspection is a work order that runs tests with no deploy: mxr inspect --jobplan drift. A PM schedules one: mxr pm add nightly-drift --cron "0 2 * * *" --jobplan drift writes the schedule into mxr.yaml and a Tekton CronJob beside it. On the cluster, mxr pipeline render turns a job plan into a Tekton PipelineRun: one mxr task per job plan task, chained in order and switched by each task's On flag.
The mistake: Switching the ui gate off for TEST because a journey keeps failing. Do this instead: Find the cause first. If the gate really is wrong for that site, change it on the board, which makes a commit with the reason in its message.
Lesson 7
Promotion, failure codes, runbooks and the twelve commands
Promotion means moving a change from one site to the next. In mxR it is the same work order and the same commit, started on the next site. Each site has gates in mxr.yaml. By default DEV has none, TEST wants a backup reference, and PROD wants a backup reference, a window and an explicit approval by a listed approver. The backup gate applies to a RESTART or a REBUILD; a HOT change passes it. The window and approval gates apply to every tier. Task gates in the job plan block on every site, DEV included.
A change package moves from DEV to TEST to PRE-PROD to PROD. At each gate a check runs and someone signs off before it moves on.
Promotion, site by site
mxr start WO1001 # COMP on DEV
mxr start WO1001 --site TEST --backup-ref db2-2026-10-31 # same work order, same commit
mxr approve WO1001 # PROD needs a named approver
mxr start WO1001 --site PROD --window "Sat 22:00"Sometimes the question is not "what changed in Git" but "what is different between UAT and PROD right now". mxr promote plan --from DEV --to UAT exports both sites and lists four groups: New (promoted), Changed (promoted, with the attributes that differ), Only on the target (kept as it is) and Excluded (held back, with the reason). Endpoints, external systems, system properties, JMS consumers, start centres, translations and the MAXADMIN group stay with each site by default. Every item carries a sha256 of its content and the work order carries a hash of the whole list. The approval records that hash. When you start, mxR reads the source again and checks every item against its hash; if anything changed since approval, it stops with exit code 2 and names the item, before anything reaches the target.
An mxR change work order goes WAPPR, APPR, INPRG and COMP on DEV, then the same work order and commit move to TEST and then PROD. Failure sends it to CAN with a failure code.
| Failure code | What it means |
|---|---|
| BUILD/COMPILE, BUILD/DBC | The Maven build failed, or a DBC script failed validation. The site is untouched |
| DEPLOY/CR-NOTREADY | The ManageWorkspace did not reach Ready inside the site's timeout |
| DBC/UPDATEDB | maxinst or updatedb failed on a customer script. Fail closed, capture the log, print the backup reference |
| DEPLOY/HOT-PARTIAL | The hot push stopped at the first failed item. Applied, skipped and failed items are in run.json; the re-run is idempotent |
| TEST/GATE, TEST/UI-FLAKY | A gated task failed (exit 2), or a UI journey passed only on its one retry, recorded as flaky, never as green |
| AUTH/INFRA | The API key or cluster access was refused (exit 3), before any browser or deploy started |
Here is a gate biting, from the real run. A commit added a script with a syntax error. Lint compiled it on the site's Jython, the gate failed, and the deploy never ran. The site stayed exactly as it was.
exit code 2: a gate blocked the run
$ mxr start WO1003
▶ lint (scripts, gate, budget 2m)
✗ lint fail 1 of 3 scripts fail to compile: MXR_DEMO_BROKEN.py (no viable alternative at input ':' (line 2))
✗ WO1003 stays INPRG on DEV: TEST/GATE — lint fail: ...
re-run: mxr start WO1003 --site DEV (resumes; finished tasks are skipped) cancel: mxr cancel WO1003 --code TEST/GATEThe runbook then offers three ways forward. Fix forward: change the repo, commit, plan and start a new work order. Resume: when the cause was outside the change, run the same start again; passed tasks are skipped. Revert: copy the pre-push export over hot/ and ship it as a normal HOT work order. And one line in bold: never switch a gate off to get past it.
| Command | What it does |
|---|---|
| mxr init | Write mxr.yaml, the site file and four job plans |
| mxr doctor | Prove the key, the agent, the grants and the test site, with a fix per line |
| mxr export | Pull live artefacts into hot/, so drift is git diff |
| mxr plan | Diff against the deployed commit, decide the tier, raise the work order WAPPR |
| mxr promote plan | Raise a work order from what differs between two sites |
| mxr approve | APPR, with the approver and, for a promotion, the list hash |
| mxr start | INPRG: deploy, run the job plan, COMP; on the next site, promotion |
| mxr inspect | Tests only, no deploy |
| mxr cancel | CAN with one failure code and its runbook |
| mxr pm add | A scheduled inspection and its Tekton CronJob |
| mxr pipeline render | The same run as a Tekton PipelineRun |
| mxr ui | The job plan board and the work order screen on localhost |
Exit codes are part of the contract: 0 ok, 1 a task or deploy failed, 2 a gate blocked the run, 3 infrastructure or authentication, 4 bad input. A runner reads these to decide what to do next.
The mistake: A gate fails on TEST, so someone edits the TEST site by hand to make it pass. Do this instead: Hand edits are exactly what drift finds and what the next promotion overwrites. Fix the repo, commit, and let a new work order carry the fix through DEV first.
Real practice on the Maximo SIM
Tasks you do by hand on the training Maximo, with the evidence your trainer checks.
- Promote your script from DEV to UAT, then check PROD (UAT). Promotion is the heart of delivery: the same change, moved the same way, checked at each step.
Check yourself: the Level 10 quiz
18 questions. Pass mark 70%.
- What is continuous integration?
- Merging big changes once a month
- Regularly merging changes into a central repository, after which automated builds and tests run
- Testing only in production
- A Maximo application
- Look at the lit lane. Who decides when a passing change goes live? (picture: CI, continuous delivery, continuous deployment, CT)
- Nobody: it goes live by itself
- A person presses release
- The unit tests
- IBM Support
- Which picture shows continuous deployment?
- First lane lit
- Second lane lit
- Third lane lit
- Fourth lane lit
- Where did this change stop, and what reached PROD? (picture: A pipeline with gates)
- It stopped at the build; nothing reached PROD
- It stopped at approval; nothing reached TEST or PROD
- It reached PROD and failed the smoke test
- It stopped at the unit tests
- Why can't a generic runner such as GitHub Actions ship a Maximo change well on its own?
- It cannot run on Linux
- It does not know Maximo artefacts: their API calls, their order, their activation steps and how to test them
- It is too expensive
- Maximo forbids pipelines
- In Tekton, what is a PipelineRun?
- A single run of a Pipeline, with its own inputs
- A Kubernetes node
- A Maximo cron task
- A Git branch
- In mxR, where does the WO1001 work order live?
- As a WORKORDER record in Manage
- In your Git repo and the run record, .mxr/runs/WO1001/run.json
- In a spreadsheet
- In the MAS admin screen
- Which bin does this path fall into? (picture: The path rule sorts every change)
- HOT
- RESTART
- REBUILD
- None: it is ignored
- Which bin does this path fall into, and what does it need? (picture: The path rule sorts every change)
- HOT: just the API key
- RESTART: cluster access
- REBUILD: cluster, bucket and admin image
- It needs a person to copy it by hand
- A commit changes only the number of replicas in sites/PROD.yaml. Which tier?
- HOT
- RESTART
- REBUILD
- No tier: site files are ignored
- Lint is a gate. A new script does not compile on the site's Jython. What happens? (picture: The job plan board)
- The script is deployed with a warning
- The deploy never runs; the work order holds INPRG with TEST/GATE and exit code 2
- The work order goes to COMP
- Lint is skipped on DEV
- What is MXR.AGENT?
- A person on the release team
- One Jython automation script on each site that exposes actions Manage has no ready-made API for, such as script.compile and cron.runNow
- A database table
- A Tekton cluster
- The work order completed on DEV. How does the same change reach TEST? (picture: An mxR work order moves site to site)
- Retype the change on TEST
- mxr start on TEST with the same work order and the same commit
- Copy the DEV database to TEST
- Email the TEST administrator
- What do mxR's default gates ask for before a change goes into PROD? (picture: From DEV to PROD)
- Nothing
- A backup reference, a window and an explicit approval by a listed approver
- Only a passing lint
- A new API key
- This work order failed and was cancelled. What does it carry? (picture: An mxR work order moves site to site)
- Nothing: it is deleted
- One failure code, and the recovery runbook printed with the work order, the site and the paths filled in
- A list of everyone who touched DEV
- A new commit
- A UI journey failed once and passed on its one retry. How does mxR record it?
- As a pass
- As flaky, with the failure code TEST/UI-FLAKY, never as green
- It deletes the journey
- As a build failure
- A site must stay free of test data. Which setting keeps the tests running?
- Turn every test off
- test: { records: virtual }: Manage validates a work order through its own business objects and discards it
- Point the tests at PROD
- Delete the test records afterwards with SQL
- mxr promote plan raised a work order from DEV to UAT and it was approved. Before start, someone edits one approved item on DEV. What does mxr start do?
- Promotes the new version silently
- Reads DEV again, finds the item no longer matches its approved hash, and stops with exit code 2 naming the item
- Promotes everything except that item without saying so
- Cancels the work order and deletes UAT records
Remember it as a picture
- Continuous integration: Merge small changes often; every change is built and tested automatically.
- Continuous delivery: Every passing change is ready to ship. A person presses release.
- Continuous deployment: Every passing change goes to production on its own, with no approval step.
- Continuous testing: Tests run at every stage, and a failing gate stops the change.
- Gate: A stage that can stop the change. Fast gates first, so mistakes are caught in seconds.
- Why runners need teaching: Each kind of Maximo change moves its own way. A runner sees files; mxR knows the lanes.
- mxR work order: Every change is a work order: WAPPR, APPR, INPRG, COMP, or CAN. It lives in Git, not in Maximo.
- HOT: hot/, tests/, jobplans/: applied through the API in a fixed order while Manage runs. Minutes.
- REBUILD: archive/ or build keys: a customisation archive and a rebuild, behind a backup reference, a window and an approval.
- RESTART: A site-file key such as JVM options: merged into the ManageWorkspace, and the operator rolls the pods until Ready.
- MXR.AGENT: One Jython script per site. Runs as the caller, writes only hot artefact tables, one audit line per call.
- Job plan and golden screens: The pipeline as data. Golden screens check every touched screen still opens with its title, toolbar and tabs.
- Promotion: The same work order and the same commit, started on the next site, through that site's gates.
- Failure code and runbook: CAN carries one code, such as TEST/GATE, and prints its runbook: fix forward, resume or revert.
Where these facts come from
- IBM Support: Applying a customization archive into IBM Maximo Manage
- IBM Documentation: Customization archive guidelines
- IBM Maximo REST API: calling an automation script
- mxR documentation: the run guide and reference
- mxR: ship Maximo changes the way Maximo ships work
- AWS: What is continuous integration and continuous delivery/deployment
- Tekton: Tasks and Pipelines
Try it on the real tools
How did Level 10 go?
Rate the level and say what worked, what did not, what you liked and what you did not. Send it now, or with your full report.