SSQP76_9.6.0 - Documentation Index
Table of Contents
IBM Operational Decision Manager 9.6.0
Release notes
What's new
Deprecated and removed features
Offline and mobile access
Support lifecycle policy
Accessibility
Additional resources
Legal information
Notices
Guidelines for GDPR readiness
FIPS 140-3 compliance
Start here
Overview
Introduction
Decision automation for business agility
Automated decision making
Decision management and governance
AI integration
Roles and activities
Tutorials
Licenses and metering
Licenses
IBM License Metric Tool
Adding license metering annotations to custom containers
Reporting compliance for your entitlement option
Capacity entitlement
Consumption entitlement
Configuring metering for Hadoop and Spark deployments
Installing
Software requirements
Getting the installation files
Installing product components
Installing components locally
Installing on Apple Silicon macOS
Installing components on multiple workstations
Creating and editing response files
Running a silent installation
Checking your installation
Folders in the installation directory
Shortcut commands
Start menu shortcuts
Installing updates
Post-installation setup
Uninstalling product components
Configuring
List of supported languages
Configuring Rule Designer
Installing the ready-to-use Rule Designer
Adding Rule Designer to an existing Eclipse
Changing the JVM used by Rule Designer
Starting Rule Designer
Opening Rule Designer in a specific locale
Selecting a display mode
Setting up Ant to automate processes
Mandatory: Create the databases
Creating the Decision Server database
Creating the Decision Center database
Completing the configuration of Decision Center
Creating the Decision Center DB2 database on z/OS
Optional: Enabling distributed caching for Decision Center
Restricting database user permissions
Selecting and applying the persistence type
Liberty: Changing the persistence type
Tomcat: Changing the persistence type
JBoss: Changing the persistence type
Creating a schema for the Rule Execution Server database
Integrating MCP servers with AI agents
Securing Operational Decision Manager
Security architecture
Configuring servers
Creating server certificates
Users, groups, and roles
Configuring clients
Enabling communication with self-signed certificates
Importing a server certificate to your environment
Connecting Rule Designer with a server certificate
Verifying server certificates
Host name verification
Configuring proxy servers
Configuring proxy servers in web browsers
Configuring proxy servers in Rule Designer
Additional server configurations
Password and account lockout policies
Protecting from fingerprinting servers
Enabling content security for REST API
Configuring HTTP methods
Configuring the HTTP Strict Transport Security policy
Configuring cookies
Configuring TLS protocols and cipher suites
Protecting against host header injection attacks
Protecting against CSRF attacks
Known vulnerabilities and remediation
Polymorphic deserialization with jackson-databind in the XOM
Protecting decision services
Decision service URL patterns
Protecting the ruleset testing user interface
Protecting decision services with basic authentication
Creating one or several new roles
Calling protected decision services
Optional protection configuration
Protecting specific RuleApps
Specifying a per-environment application context root
Configuring for OpenID Connect
Prerequisites and limitations
Overview: OpenID Connect
Configuring OpenID Connect Relying Parties
Samples
Preconfigured sample files for Liberty
Running the sample files on the sample server
Configuring Relying Parties in the Liberty server
Configuring Rule Execution Server
Configuring the hosted transparent decision service
Passing parameters and registering the truststore
Configuring Decision Center
Defining OpenID Connect Providers for Decision Center
Passing parameters to the Decision Center Business console
Updating the Decision Center database schema
Selecting an OpenID Connect Provider in the Decision Center Business console
Registering the truststore and obtaining a token
Configuring Rule Designer
Defining OpenID Connect Providers for Rule Designer
Passing parameters to Rule Designer
Selecting an OpenID Connect Provider in Rule Designer
Configuring an OpenID Connect Provider
Configuring compliance settings
Configuring for FIPS 140-3 compliance
Security and Privacy by Design
Configuring on Liberty profile
Configuring Rule Execution Server on the Liberty profile
Before you start
Step 1: Deploying the Rule Execution Server management archive
Step 2: Deploying the hosted transparent decision service
Step 3: Deploying the testing and simulation archive
Creating a schema for the Rule Execution Server database
Completing the configuration of Rule Execution Server
Configuring Rule Execution Server for different environments
Configuring Decision Center on the Liberty profile
Before you start
Step 1: Creating a data source
Step 2: Configuring user access to Decision Center
Step 3: Deploying the Decision Center WAR files
Completing the configuration of Decision Center
Configuring on Tomcat
Configuring Rule Execution Server on Tomcat
Before you start
Step 1: Deploying the Rule Execution Server management archive
Step 2: Deploying the hosted transparent decision service
Step 3: Deploying the testing and simulation archives
Creating a schema for the Rule Execution Server database
Completing the configuration of Rule Execution Server
Configuring Rule Execution Server for different environments
Configuring Decision Center on Tomcat
Before you start
Step 1: Creating a data source and connection pool
Step 2: Configuring user access to Decision Center
Step 3: Deploying the Decision Center archives
Completing the configuration of Decision Center
Configuring on JBoss
Configuring Rule Execution Server on JBoss
Before you start
Step 1: Configuring access to Rule Execution Server
Step 2: Creating a driver and data source
Installing a JDBC driver as the core module
Creating the data source
Step 3: Deploying the execution unit (XU) RAR file and Rule Execution Server management EAR
Step 4: Deploying the testing and simulation archive
Step 5: Deploying the hosted transparent decision service
Creating a schema for the Rule Execution Server database
Verifying the configuration
Rule Execution Server deployment for high availability and scalability
Configuring Rule Execution Server for different environments
Deploying Rule Execution Server in a cluster
Setting up JBoss to allow unescaped characters in URLs
Configuring Decision Center on JBoss
Before you start
Step 1: Creating a data source and connection pool
Step 2: Configuring user access to Decision Center
Completing the configuration of Decision Center
Configuring on Java SE
Configuring Rule Execution Server on Java SE
Before you configure Rule Execution Server on Java SE
Setting the class path for Java SE
Packaging JAR files for Rule Execution Server on Java SE
Changing the persistence mode
Upgrading and migrating
Upgrade and migration path
Learn why you should upgrade
Prepare for your upgrade
Understand the migration scenarios
Install the latest version
Upgrade your environment
Migrating customizations
Move to the Business console
Move to the decision engine
Verify your migration
Using the Decision Center database dump tool
Exporting Decision Center data
Importing Decision Center data
Migrating the Decision Center database
Preparing your database for MySQL update
Ant tasks for database migration
REST API for database migration
Migrating the database progressively
Rolling upgrade of components
Overview
Rolling upgrade to a newer version
Upgrading the Rule Execution Server console and execution stacks
Upgrading in a Java SE deployment
Upgrading in a Jakarta EE deployment
Upgrading Decision Center
Upgrading Rule Designer
Moving from on premises
Samples
Finding product samples
Running samples from the Samples Console
Restoring sample databases
Using the sample server
Setting the path to the Liberty server
Checking the server port number
Starting and stopping the sample server
Starting the sample server
Starting the server in debug mode
Stopping the sample server
Troubleshooting the sample server
Setting the encoding in the server trace
No WLP Ant task can be found error when starting the sample server
Restoring the sample server
Migrating between H2 databases
Decision Server Rules
Overview
Tutorials
Getting started with business rules
Before you start
Starting the Miniloan web application
Task 1: Designing the main rule project in the decision service
Task 2: Orchestrating the rules
Task 3: Authoring rules
Task 4: Testing and debugging
Task 5: Deploying and running your ruleset
Task 6: Monitoring
Task 7: Publishing to Decision Center
Summary
Rule Designer tutorials
Creating a decision service with multiple projects
Before you start
Running the completed tutorial
Task 1: Creating a main rule project for the decision service
Task 2: Creating decision operations
Task 3: Creating run configurations for the decision operations
Task 4: Creating and using deployment configurations
Defining a vocabulary
Before you start
Viewing the completed tutorial
Task 1: Creating a BOM entry
Task 2: Verbalizing new business elements
Task 3: Testing the vocabulary in an action rule
Task 4: Extending the business object model
Task 5: Refining the vocabulary
Task 6: Creating a domain
Creating and defining a ruleflow
Before you start
Viewing the completed tutorial
Task 1: Creating a ruleflow
Task 2: Defining the eligibility rule task
Task 3: Defining the pricing rule task
Task 4: Setting a condition on a transition
Task 5: Executing the ruleflow and analyzing the results
Editing decision tables
Before you start
Viewing the completed tutorial
Task 1: Importing the projects to start the tutorial
Task 2: Creating the MinimumAge decision table
Task 3: Generating lines of data in the table
Task 4: Correcting an overlapping data error
Task 5: Importing data from Excel into a decision table
Task 6: Changing cell formats
Task 7: Running the decision table
Debugging a decision service
Before you start
Running the completed decision service
Task 1: Using automatic exception handling
Task 2: Setting breakpoints
Task 3: Debugging a rule
Task 4: Debugging a decision table
Task 5: Debugging a ruleflow
Configuring the BOM for Excel testing
Before you start
Running the completed tutorial
Task 1: Selecting a constructor
Task 2: Customizing column headings
Task 3: Customizing the Expected Results sheet
Task 4: Using domains with the Excel scenario file
Rule Execution Server tutorials
Managing RuleApps
Before you start
Task 1: Checking the Rule Execution Server console
Task 2: Deploying a RuleApp by using the REST API
Task 3: Testing the ruleset
Task 4: Deploying a RuleApp by using the Rule Execution Server console
Task 5: Working with RuleApp archives by using Ant tasks
Running a hosted transparent decision service
Before you start
Task 1: Deploying a RuleApp from Rule Designer
Task 2: Ensuring the ruleset is usable in REST
Task 3: Retrieving an OpenAPI description and calling the decision service in a generated client
Task 4: Retrieving a WSDL description and calling the decision service with a generated client
Task 5: Inspecting the performance of the decision service
Samples
Opening the Rule Execution Server console on the sample server
Rule Designer samples
Authoring extensions
BAL collections
Setting up the BAL collections sample
BAL collections sample details
Custom value editor
Setting up the custom value editor sample
Custom value editor sample details
Context-aware rule definition
Setting up the context-aware rule definition sample
Context-aware rule definition sample details
Data sources for BOM domains
Setting up the data sources for BOM domains sample
Data sources for BOM domains sample details
Data sources for decision tables
Setting up the data sources for the decision table sample
Data sources for decision tables sample details
Modified BOM core types
Setting up the modified BOM core types sample
Modified BOM core types sample details
Business rule management extensions
Automated query execution
Setting up the automated query execution sample
Automated query execution sample details
Automated decision service deployment
Automated decision service deployment sample setup and details
Rule model extensions
Setting up the rule model extensions sample
Rule model extensions sample details
Rule Execution Server samples
Simple execution
Setting up the simple execution sample
Simple execution sample details
File ruleset execution
Setting up the file ruleset execution sample
File ruleset execution sample details
Memory ruleset execution
Setting up the memory ruleset execution sample
Memory ruleset execution sample details
Ruleset execution
Setting up the ruleset execution sample
Ruleset execution sample details
Ruleset management and execution
Setting up the ruleset management and execution sample
Ruleset management and execution sample details
Execution trace
Setting up the execution trace sample
Execution trace sample details
Machine Learning integration
Integrating a Machine Learning model
Testing the integration in Rule Designer
Updating Machine Learning references
Deleting Machine Learning references
Connecting to the Machine Learning service
Updating the JVM options in the Liberty server
Adding a Machine Learning configuration file as a XOM resource
Machine Learning return codes
Example: Adding a Machine Learning model
Downloading the Machine Learning model
Importing and running the model
Exporting JSON for a cloud-hosted Machine Learning endpoint
Scripts to export Machine Learning models
Developing rulesets in Rule Designer
Setting up rule projects
Setting up a project hierarchy
Defining rule project references
Defining a folder structure for rule project items
Rule project item naming conventions
Creating a rule project template
Improving performance on large rule projects
Orchestrating ruleset execution
Comparing ruleflow editors
Working with ruleflows
Overview: Ruleflows
Creating a ruleflow
Configuring rule task execution
Runtime rule selection
Execution properties for rule tasks
Configuring ruleflow properties
Configuring rule execution
Updating object states in the rule engine
Object state update
Notifying the rule engine of object updates
Ordering rules in a ruleset
Setting simple priorities among rules
Rule overriding
Defining rulesets
Defining the ruleset content and signature
Extracting rules for a ruleset
Creating a custom ruleset extractor validator
Integrating a custom ruleset extractor validator into Rule Designer
Designing projects for rule authoring
Designing business object models
Overview: BOM and execution object model (XOM)
Creating BOM entries
Creating a BOM without a XOM
Creating an empty BOM entry
Disabling BOM to XOM mapping checks
Associating an empty BOM entry with a XOM
Creating a BOM entry from a XOM
Specifying the order of BOM entries
Accessing properties at run time
Designing a BOM for a Java model
Defining a Java XOM for a rule project
Defining a Java XOM
Adding a JAR file or class folder to a Java XOM
Setting the source location of a library
Defining the order of Java XOM entries
Defining BOM-to-XOM mapping
Rule language and extender mapping
Execution class mapping
Rule language mapping
Extender mapping
Accessing decision engine and related artifacts from ARL mapping code
Mapping of a BOM created from a Java XOM
Adding annotations to the XOM
XOM annotations
@NotBusiness
@BusinessName
@BusinessType
@BoundedIntDomain
@CollectionDomain
@PatternDomain
@CustomProperty
@CustomProperties
@java.beans.ConstructorProperties
Designing a BOM for an XML model
Overview: Dynamic execution object model (XOM)
Defining a dynamic XOM for a rule project
XML binding
What is XML binding
Stage 1: XML schema processing
Stage 2: XML document processing
Using the XML binding API
Adding XML objects to the working memory
Add XML objects and load XML documents into the rule engine
Adding the root object of an XML document
Using XML objects as ruleset parameters
Assigning the root element name of an XML object
Reading XML documents for the decision engine
Writing to XML documents for the decision engine
Managing unknown operators on attributes and elements
Configuring XML binding
Inspecting an XML model
Retrieving reflection information on a data driver
Retrieving reflection information on a schema
Retrieving reflection information on a user simple type
Processing reflection information on a user complex type
Configuring the mapping between XML schema and dynamic classes
Configuring the XML parser
Handling XML binding error and warning messages
Configuring an XML data driver
Configuring an XML data driver by using a configuration file
Configuring an XML data driver by using an XML helper
Parameterizing an XML data driver
Making an XML data driver multithread safe
Retrieving XPath information on XML objects
Mapping between XML schema and dynamic classes
Map function
Schema types
Built-in simple types
Simple type mapping
Simple types derived from other simple types
List types and union types
Local simple types mapped to inner classes
Complex types
Extension of simple type content in complex types
Complex type restriction
Complex type extension
Local complex types mapped to inner classes
Default constructor dynamic methods
Type identifier mapping
XML declarations
Elements
Attributes
Groups
appinfo
Schema-related markup in XML documents
Schema mapping limitations
Designing a BOM for a PL/I model
PL/I data models and execution options
Object model and deployment options for PL/I
Workflows that start from a PL/I include file
PL/I data type support
Guidelines for PL/I XOM generation
Data structures in the PL/I include file
PL/I to Java mapping
%INCLUDE statements in the include file
PL/I data item mapping to Java structures
Group items and data items in PL/I
Top-level data items in PL/I
Array mapping between PL/I and Java
BIT string mapping from PL/I to Java
UNION statements in the PL/I include file
Setting the options for the PL/I include file importer
Importing the Java BitSet class
Generating a PL/I XOM
Mapping PL/I structures to Java data types
Identical PL/I structures
Mapping PL/I data items to boolean and date types
Mapping PL/I arrays to the List type
Remapping a PL/I structure to a Java class type
Selecting a string trim type for the String type
Creating custom types for PL/I data items
Custom types for PL/I
Defining your own type converter for PL/I
Applying a custom type converter for PL/I
Updating a PL/I XOM
Deleting a PL/I XOM
Updating the BOM after a PL/I include file changes
Converting a BOM to enable the BOM for PL/I
Mapping Java data types to PL/I data models
Role of the PL/I include file
Supported Java data types for mapping to PL/I data models
Collection type
Enum type
Map type
Enabling the BOM for PL/I include file generation
Creating the BOM to PL/I mapping
Generating the PL/I include file
Updating the BOM when the XOM changes
Managing changes to the XOM from a Java project
Managing changes to the XOM from a rule project
Configuring BOM updates to ignore differences
Preserving your changes to the Java XOM when the z/OS data model is updated
Designing business object models for COBOL
Designing a BOM for a COBOL subprogram
Designing a BOM for a COBOL model
COBOL data models and execution options
Object model and deployment options
Workflows that start from a COBOL copybook
Workflows that start from a Java XOM
Handling data type differences between Java and COBOL
Guidelines for COBOL XOM generation
Data structures in the COBOL copybook
COBOL to Java mapping
COPY statements in the copybook
COBOL data item mapping to Java structures
Group items and data items
Top-level data items
REDEFINES statements in the copybook
Table mapping between COBOL and Java
Setting the copybook importer options
Generating a COBOL XOM
Mapping COBOL structures to Java data types
Identical COBOL structures
Mapping COBOL data items to boolean and date types
Mapping COBOL fixed-length tables to the List type
Remapping a COBOL structure to a Java class type
Selecting a string trim type for the String type
Creating custom types for COBOL data items
Custom types
Defining your own type converter
Applying a custom type converter
Updating a COBOL XOM
Deleting a COBOL XOM
Implementing BOM methods for COBOL code generation
COBOL methods
Method parameter types
Creating macro methods
Example: Creating a macro method to check data types
Creating mapped methods
Changing data definitions for mapped method parameters
Example: Creating a mapped method to call external COBOL code
Placeholders, arrays, and nested arrays
Example: Using placeholders, arrays and nested arrays
Updating the BOM when a copybook changes
Converting a BOM to enable the BOM for COBOL
Mapping Java data types to COBOL data structures
Role of the COBOL copybook
Supported Java data types for mapping to COBOL data structures
Collection type
Enum type
Map type
Unsupported characters and reserved words
Enabling the BOM for COBOL copybook generation
Creating the BOM to COBOL mapping
Generating the COBOL copybook
Sharing a BOM between Java, COBOL, and PL/I applications
Configuring the BOM for rule authoring
Overview: A data model for rule authoring
Business object model (BOM)
Introducing the business object model (BOM)
Collections
Creating BOM elements
Creating packages and classes
Adding nested classes
Adding members to a class
Declaring ownership relations on BOM classes to simplify rules
Defining a vocabulary
Vocabulary
Vocabulary elements
Phrase templates
Placeholders
Simplified phrase templates
Default verbalization
Vocabulary errors and warnings
Defining the vocabulary for a BOM entry
Editing terms
Documenting terms
Editing and creating phrases
Editing a phrase
Editing the subject of a phrase
Creating new phrases
Using a reduced verbalization for simpler rules
Documenting phrases
Editing the verbalization of constants
Editing the verbalization of ruleset variables
Editing the verbalization of ruleset parameters
Working with categories
Categories
Defining and assigning categories
Working with domains
Domains
Defining domains
Excel domain provider
Creating dynamic domains from Excel
Updating a single dynamic domain
Updating all dynamic domains
Working with domains and z/OS data models
Domains for z/OS data models
Creating a domain class for z/OS rule projects
Defining Java domains for z/OS rule projects
Referencing a Java project
Assigning domain types in a COBOL copybook import wizard
Assigning domain types in a PL/I include file import wizard
Creating dynamic domains for COBOL projects in an Excel file
Customizing business rule authoring and management
Overview: Customizing business rule authoring and management
Customizing rule authoring
Options for customizing rule authoring
Creating dynamic domains
Extending BOM value types
BOM value type extensions
Extending a BOM value class or member
Creating a value descriptor
Example: Creating a color value descriptor
Example: Defining a decorated value descriptor
Example: Prefixing a number or string value
Associating a value editor with a BOM type
Creating a value translator
Example: Implementing a value translator in Rule Designer
Creating a value info
Creating a value provider
Example: Implementing a city by state value provider in Rule Designer
Creating a value checker
Example: Implementing a city value checker with a constraint
Configuring a custom locale in Rule Designer
Customizing collections in the BOM
Transforming the content of a collection to a String
Working with arrays and collections
Casting multiple-cardinality elements to single-cardinality elements
Reference
BOM properties
Vocabulary properties
Concrete syntax properties
Concrete and global syntax properties
Properties common to all types
Properties of a sequence type
Properties of an element of a sequence type
Properties of a single element of a sequence type
Properties of an optional element of a sequence type
Properties of a multiple element of a sequence type
Properties of a terminal type
Properties of the tree view of the completion menu
Integrating business rule management extensions into Rule Designer
Integrating rule model extensions into Rule Designer
Implementing a custom property editor for Rule Designer
Custom editors
Implementing a custom editor for a specific property
Implementing a custom editor for all properties of a specific type
Integrating callbacks on properties into Rule Designer
Integrating initial values for properties into Rule Designer
Integrating extractable property handlers into Rule Designer
Integrating rule authoring extensions into Rule Designer
Integrating dynamic domains into Rule Designer
Integrating a value descriptor into Rule Designer
Implementing a value editor for Rule Designer
Example: Implementing a color value editor in Rule Designer
Integrating a value translator into Rule Designer
Integrating a value info into Rule Designer
Integrating a value provider into Rule Designer
Integrating a value checker into Rule Designer
Integrating an extension as a Rule Designer plug-in
Creating a plug-in project
Defining a plug-in extension
Deploying a plug-in
Rule Designer Extension Points
Translating an existing rule project and vocabulary
Translating an existing business vocabulary
Translating rule project items
Authoring business rules
Overview: Ways to express business rules
Working with action rules
How action rules work
Rule variables
Types of rule variables
Rule conditions
Conditions that compare business terms and values
Conditions that test for existence
Conditions that test set membership
Combinations of conditions
Condition negation
Rule actions
Dependency of rule actions on rule variables
Action rule editing errors and warnings
Creating an action rule
Selecting editing options for action rules
Building rules using the Intellirule editor
Overview: Intellirule rule editor
Creating rule parts
Using punctuation to clarify rules
Highlighting and correcting errors
Using action rules to open business elements
Editing a business element from the text of a rule
Editing a business element from the Vocabulary Browser
Creating an action rule type
Working with decision tables
Decision tables
Columns
Rows and cells
Preconditions
Customizing operators
Decision table errors and warnings
Creating a decision table from scratch
Editing decision tables
Comparing decision table editors
Working in the default editor
Keyboard shortcuts
Defining columns
Adding and removing columns
Sorting and moving columns
Adding and populating rows
Specifying values and operators
Specifying values
Specifying default action values
Setting default operators for columns
Disabling and enabling action cells
Populating a decision table from an Excel spreadsheet
Defining preconditions
Formatting columns in a decision table
Defining checking options
Value test conditions
Using decision table locking facilities
Viewing rule details
Documenting a decision table
Working in the legacy editor
Defining columns
Adding and removing columns
Sorting and moving columns
Adding and populating rows
Adding and deleting a row
Adding a partially completed row
Adding an otherwise row
Populating rows with values from an enumerated domain
Adding rows that contain values
Moving rows
Splitting rows
Merging rows
Specifying values and operators
Specifying values
Setting default operators for columns
Disabling action cells
Populating a decision table from an Excel spreadsheet
Defining preconditions
Formatting a decision table
Defining checking options
Value test conditions
Using decision table locking facilities
Viewing rule details
Viewing the decision table as a spreadsheet
Documenting a decision table
Working with variables
Variables available for rule authoring
Setting up automatic variables
Defining ruleset variables
Creating a variable set
Defining a ruleset variable
Modifying the verbalization of a ruleset variable
(Deprecated) Working with decision trees
Decision trees
(Deprecated) Decision tree overview
Decision tree editing errors and warnings
Creating a decision tree
Labeling and defining condition nodes
Labeling a condition node
Defining a condition node
Inserting a condition node
Inserting a new condition node after a branch
Deleting a condition node
Labeling and defining branches
Defining a branch
Labeling a branch
Inserting a new branch
Inserting an Otherwise branch
Changing a branch to and from Otherwise
Inserting and defining branches for enumerated domain values
Duplicating a branch
Deleting a branch
Labeling and defining actions
Labeling an action set
Defining an action
Adding an action to an action set
Changing the order of actions
Deleting actions
Defining preconditions
Defining checking options
Viewing rules
Working with technical rules
Technical rules
Technical rules
Variables in technical rules
Technical rule conditions
Technical rule actions
Action part of a technical rule
If/Else control
Loops
Branching statements
Exception handling statements
Else clause with an evaluate statement
Creating a technical rule
Using the Technical Rule Editor
Using Content Assist in a technical rule
Errors in the Technical Rule Editor
Organizing import statements
Opening declarations from the Technical Rule Editor
Defining IRL editing settings
Writing technical rules
Writing the basic structure of a technical rule in IRL
Defining a variable
Writing conditions in IRL
Adding tests to a condition
Using objects that are not in memory in a condition
Writing actions in IRL
Writing a rule with an else action clause
Notifying the rule engine of object changes
Working with functions
Functions
Creating functions
Working with properties
Properties
Tags
Hierarchies
Applying a category filter
Defining a calendar format
Rule authoring for COBOL compatibility
BAL keywords and features
Variable mapping for COBOL
Rule variables
Defining variable sets and ruleset variables
Number rounding
COBOL rule validation
Correcting errors by using Quick Fix
Applying verbalization changes to business rules
Reviewing a rule project
Overview: Querying and reporting
Searching
Searching rule project elements
Searching for packages and rule files
Searching for a project element
Searching the execution object model
Searching for XOM classes and packages
Searching the current XOM
Searching the business object model
Searching the BOM classes and packages
Searching the current BOM
Querying
Queries
Introducing queries
Query conditions
Queries on properties
Queries on definitions
Queries on semantic content
Queries on rule dependencies
Queries on categories
Query actions
Query synchronization between Rule Designer and Decision Center
Creating a query
Running a query
Finding rule dependencies
Customizing queries
Creating query extensions
Integrating query extensions into Rule Designer
Automating queries with the Rule Designer API
Analyzing
Rule analysis
Introducing rule analysis
Consistency checking
Rule analysis settings
Completeness analysis
Analyzing a rule project
Analyzing a rule project
Resolving ambiguities and conflicts
Instantiating the missing rules
Fine tuning rule project analysis
Filtering the results
Displaying the results
Creating multiple views
Generating Rule Project Statistics reports
Testing and simulating rulesets
Overview of testing and simulation
Testing and simulating rulesets in Decision Center
Working with the Decision Runner
Making the XOM accessible by deploying the XOM
Testing rulesets in Rule Designer
Running a custom test
Working with Excel scenario files
Excel scenario files
Relationship between the BOM and the Excel file
Adding columns to the Excel file
Removing columns from the Excel file
Validating the project
Generating an Excel scenario file
Updating domain information in the Excel scenario file
Using empty collections in test suites
Customizing testing and simulation
Providing a custom implementation for tests
Using additional data files
Building and running rules
Overview: Building and running rules
Building rule projects interactively
Automating builds
Automating builds with Rule Designer
Rule Designer build automation tool
Advanced automation by using JavaScript
Rule Designer command-line tool
Calling the Rule Designer command-line tool
Command-line global variables
Adding global variables
Automating builds with Build Command
Building projects with the Build Command Line
Writing the configuration file
Building projects
Building projects with the Build Command Maven plug-in
Preparing your environment
Setting up your projects
Building projects
Running and debugging
Running and debugging decision operations
Debugging rulesets
Ruleset debugging tools
Starting a debugging session
Setting breakpoints in rules
Setting breakpoints in the working memory
Setting breakpoints in the BOM
Stepping through the rule execution code
Inspecting the working memory
Inspecting the agenda
Viewing and evaluating expressions
Viewing variable values
Viewing breakpoints
Executing rulesets
Decimal precision for numbers
Running rules on the decision engine
Decision engine
Limitations of the decision engine
Application programming interface (API) for the decision engine
Optimizing execution
Overview: What affects the performance of a Decision Server application
Performance guidelines
Choosing an execution mode
General rule engine concepts
Engine execution modes
RetePlus mode
RetePlus algorithm
Sequential mode
Sequential algorithm
Fastpath mode
Deciding on an execution mode
Changing the execution mode
Data accessibility
Exception handling in rules
Automatic exception handling in conditions
Examples of automatic exception handling
Setting a custom exception handler
Runtime efficiency
Java and the rule engine
Optimizing the decision engine
Using the same definition for several decision engines
Adjusting conditions
Improving the performance of the RetePlus execution mode
RetePlus algorithm
Optimizing the object model
Improving the performance of the sequential execution mode
Improving the performance of the Fastpath execution mode
Stopping a rule task
Deploying rules
Overview: Deployment options
Deployable packages
Deployment architecture
Deploying decision services
Deployment configurations
XOM deployment with decision services
Version policies
Deploying decision services from Rule Designer
Automated deployment of decision services
Managed Java XOM
Managed Java XOM setup and lifecycle
Java XOM artifacts
Limitations
Deploying and writing RuleApps by running Ant tasks
Developing client applications
Execution components
Execution patterns
Rule sessions
Setting up ruleset execution traces
Execution trace API
Retrieving ruleset execution traces
Ruleset interceptors
Ruleset parsing and the ruleset cache
RuleApp execution code generators
Creating a client for Rule Execution Server
Using Java SE factories
Calling a ruleset using a Java SE factory
Packaging Java rule sessions for Java SE
Using POJO factories
Calling a ruleset using a POJO factory
Packaging Java rule sessions for Jakarta EE
Calling a ruleset asynchronously
Adding a decision identifier
Creating a POJO client project for RuleApps
Adding RuleApp execution artifacts to an existing project
Customizing execution code generators
Adding a new execution code generator
Creating a plug-in project to declare a generator
Modifying the generator used in the RuleApp code generation wizards
Writing a new code generator class
From the IlrVelocityGenerator class
From the IlrTraceFileGenerator class
From IlrPOJOGenerator
Writing a new nested wizard
Executing rules by using the REST service
REST resources
Endpoint URIs
HTTP methods
HTTP headers and URI parameters
Content types
Setting the InfoRulesFiredPropertiesFilter parameter
Request and response schema
XML serialization of ruleset XOMs
JSON serialization of ruleset XOMs
Executing a ruleset by creating a REST request
Generating a WADL representation
Generating an OpenAPI representation
JNDI bindings
Reference bindings for Rule Execution Server modules
Local bindings
Cascading ruleset execution
Executing a child ruleset
Excluding the XU and the RuleSession class from the managed XOM
Triggering a child ruleset execution from a technical rule
Triggering a child ruleset execution from an action rule
Sharing objects between the application and the rulesets
Passing objects from the application to the rulesets
Creating objects in the main ruleset and using them in the child ruleset
A code sample to release the child XU
A code sample to differentiate the XU logging
Usage of Java date and time types in HTDS
Managing rule execution
Rule Execution Server overview
Introducing Rule Execution Server
Developing your client application
Java SE and Jakarta EE applications
Rule Execution Server architecture
Code generators and client execution code
Testing your applications
Rule Execution Server set up for production
Improving the performance of Rule Execution Server
Administering Rule Execution Server
Rule Execution Server administration artifacts
Rule Execution Server console and user roles
Rule Execution Server basics
Rule Execution Server components
Execution and management stacks
Execution unit (XU)
Packaging and deployment
XU services for resource management
XU services for execution
Execution unit (XU) and Java class loading
Rule Execution Server persistence layer
File persistence in Java SE
Database persistence
Database schemas
Database scripts
Memory persistence in Java SE
Loading RuleApps in the memory persistence explicitly
Loading RuleApps in the memory persistence implicitly
Transparent decision services
Configuring a Rule Execution Server instance
Rule session tuning
Changing the default behavior of the execution stack
Configuring Rule Execution Server in scoped mode
Configuring Rule Execution Server in shared mode
XU configuration properties for Jakarta EE
Turning on the trace autoflush
Enabling ruleset monitoring
Managing the maximum idle time of rulesets
Customizing the ruleset cache
Setting the compiled archives cache
Setting up ruleset parsing
Turning off the asynchronous mode
Forcing synchronous parsing in asynchronous mode
Changing persistence parameters
Changing the ruleset persistence type in the console
Changing the ruleset persistence type in the XU by using the deployment descriptor file
Changing the ruleset persistence type in the XU by using APIs
Changing the Java XOM persistence type
Changing the persistence type by using an Ant task
Adding database user access to the persistence type
Setting concurrent access rights
Configuring the execution stack on Java SE
XU configuration properties for Java SE
Enabling JDK logging in Java SE
Disabling log traces in Java SE
Changing connection pool settings in Java SE
Storing Java SE execution traces in Decision Warehouse
Determining the optimal XU pool size
Changing the default behavior of the management console
Configuring the Rule Execution Server console EAR for TCP/IP management
Configuring execution units (XU) to connect to a TCP/IP management server
Notification of ruleset updates to the execution unit
Notifying a XU on Java SE of a ruleset update
Notifying a XU on Jakarta EE of a ruleset update
Managing Rule Execution Server
Rule artifact management and deployment
Managing resources by using the REST API
Accessing the REST API
REST resources
Resource URIs
HTTP methods
HTTP header fields and URI parameters
Content types
Retrieving a WADL representation
Executing rules with an embedded rule engine
Calling decision services
Calling a decision service by using the REST API
Calling a decision service as a SOAP web service
Monitoring Rule Execution Server events
Setting the granularity of log messages
Setting a logger to a Java SE rule session
Receiving notification of rule engine events using the API
Extending the EventPlugin class
Extending the plug-in
Writing a plug-in for a ruleset
Packaging the XU event plug-in
Configuring the execution unit (XU) for the XU plug-in
Emitting runtime events
Runtime events
Configuring for Apache Kafka
Enabling the event emitter
Tuning the event emitter
Disabling the event emitter
Configuring for IBM Business Automation Insights
Decision Warehouse
Audits of executed decisions
Default use of Decision Warehouse
Enabling ruleset execution monitoring
Customizing Decision Warehouse
Adding data sources to Decision Warehouse
Overview: Multiple data sources in Decision Warehouse
Configuring the calling client application
Configuring the Rule Execution Server console
Customizing a Decision Warehouse data source
Optimizing Decision Warehouse
Specifying filters on a ruleset
Removing BOM serialization
Using Rule Execution Server console
Introducing the Rule Execution Server console
Opening the Rule Execution Server console and signing in
User interface components
Top banner
Commands
Tables and filters
Limitations on zRule Execution Server for z/OS
Managing RuleApps
Archiving RuleApps
Deploying RuleApp archives
Adding RuleApps
Setting RuleApp properties
Versioning policy options
Managing rulesets
Setting HTDS options
Configuring the hosted transparent decision service location
Configuring a web service endpoint
Changing target namespaces
Testing a ruleset for REST execution
Setting ruleset properties
Built-in ruleset properties
Built-in ruleset properties for the Decision MCP Server integration
Built-in ruleset properties for OpenAPI
Built-in ruleset properties for Decision Warehouse
Built-in ruleset properties for the ODM event emitter
Setting the ruleset property for increasing rule execution performance
Managing Java XOM resources and libraries
Java XOMJava resources
JavaJava XOM libraries
Embedded managed Java XOM in Rule Execution Server
Removing referenced Java XOM resources and libraries
Removing referenced Java XOM resources
Removing referenced Java XOM libraries
Monitoring ruleset execution
Enabling and disabling the debug mode
Setting the Decision Warehouse ruleset monitoring options
Generating ruleset statistics
Ruleset statistics views
Testing ruleset execution
Viewing logged events on execution units (XU)
Managing transparent decision services
Viewing or downloading an HTDS description file
HTDS decision trace filters
Monitoring and managing the server
Configuring the Rule Execution Server console web application
Viewing debug traces for an execution unit (XU)
Viewing extended diagnostic information of execution units
Monitoring and managing Decision Warehouse
Filtering trace information
Viewing the executed rules in Decision Center
REST management API
Using the REST management API with Swagger UI
Viewing the OpenAPI representation
Viewing the WADL representation
Reference
Rule Designer reference
Rule Designer API
File types
XML rule artifact files
BOM files
Vocabulary files
BOM to XOM mapping files
Rule project files
Rule languages
Business Action Language (BAL)
BAL constructs
all of the following conditions are true
any of the following conditions is true
called (variable)
definitions
else
for each (object) in (list)
from (object)
if
in (list)
it is not true that (a condition)
none of the following conditions are true
print (string)
set (variable) to (definition)
set (variable) to (value)
the name of this rule
the number of (objects)
then
there are (number) (objects)
there are at least (number) (objects)
there are at most (number) (objects)
there are less than (number) (objects)
there are more than (number) (objects)
there is at least one (object)
there is at most one (object)
there is no (object)
there is one (object)
where (test)
BAL operators
Arithmetic operators
Logical operators
Date operators
Number operators
Object operators
Text operators
BAL literals
Numbers
Strings
Dates and times
Punctuation in rules
ILOG Rule Language (IRL)
IRL keywords
after
agendafilter
algorithm
allrules
as
before
body (in flowtask)
body (in action task)
body (in ruletask)
break
case
catch
collect
(Deprecated) completionflag
continue
default (in ruletask)
default (in switch)
dynamic
dynamicselect
else (in if)
else (in rule)
evaluate
event (in rule conditions)
event (in rule actions)
exists
filter
finalaction
finally
firing
firinglimit
flowtask
for
foreach
fork
from
function
functiontask
goto
hasher
hierarchy
if
if (in ruleflow)
import
in
in — !in (predicates)
in (ruleset parameter)
initialaction
inout
insert
instanceof
instances
isknown
isunknown
(Deprecated) iterator
literal
(Deprecated) logical (in insert)
logical (in wait)
match
matchedclasses
modify
new
not
occursin
ordering
out
overriding, overrides
package
priority
property
propertydefinition
refresh
retract
return
rule
rule (in ruletask)
ruleset
ruletask
sequential
sorted
switch
then
throw
timeof
timeout
try
until
update
use
variables
wait
when
where
while
while/break/continue (in ruleflow)
IRL grammar
Operator summary
Naming restrictions
Grammar notation
Grammar specification
Advanced Rule Language (ARL)
Differences between ARL and Java 7
ARL rules examples
Decision engine properties
Decision engine versions
Messages
Rule Execution Server reference
Rule Execution Server API
Rule Execution Server REST API
REST API GetRuleAppArchive query parameter options
Rule Execution Server management API
Configuration properties for execution units
Persistence properties for execution units
Rule Execution Server console and parameters
Context parameters for the Rule Execution Server console
Hosted transparent decision services reference
XML serialization of Java types
HTTP status codes
HTDS context parameters
Ant tasks
API mappings for Ant tasks
Ant tasks for Rule Execution Server setup
setup
Ant tasks for RuleApp management
res-jar
res-fetch
res-fetch-all
res-deploy
res-undeploy
res-write-file
res-write-db
res-delete-file
res-delete-db
Ant tasks for Java XOM management
res-deploy-xom
res-fetch-all
res-undeploy-xom
res-write-xom-file
res-delete-xom-file
res-write-xom-db
res-delete-xom-db
res-get-xom-libraries
res-get-xom-resources
res-diagnose-xom-uri
Rule Execution Server Messages
Decision Center
Overview
Tutorials
Getting started with decision services
Before you start
Task 1: Evaluating and assigning changes
Task 2: Creating and editing rules
Task 3: Testing and deploying the decision service
Exploring decision services in a governance workflow
Before you start
Task 1: Exploring a decision service in the governance framework
Task 2: Finishing work on a change activity
Task 3: Reviewing and approving the changes
Task 4: Completing and deploying the release
Editing a decision table
Before you start
Task 1: Editing a decision table
Task 2: Changing the preconditions and the rules
Task 3: Fixing errors in the decision table
Creating a ruleflow
Before you start
Task 1: Exploring a ruleflow
Task 2: Creating a ruleflow
Task 3: Exploring the sequencing features
Creating a simulation
Before you start
Task 1: Creating metrics and KPIs
Task 2: Creating and uploading a scenario file
Task 3: Formatting a report
Task 4: Running a simulation
Merging branches
Before you start
Task 1: Creating branches and modifying rules
Task 2: Merging the branches
Using the REST API tool
Before you start
Task 1: Exploring the REST API tool
Task 2: Building a decision service in the REST API tool
Task 3: Testing a decision service in the REST API tool
Task 4: Deploying a decision service in the REST API tool
Accessing LDAP registries
Before you start
Task 1: Preparing the LDAP environment
Task 2: Adding the LDAP to the security realm
Task 3: Importing to the Decision Center database
Task 4: Enforcing security on decision services
Samples
Opening Decision Center on the sample server
Authoring extensions for Decision Center
GUI customization
Setting up the GUI customization sample
GUI customization sample details
Custom value editor
Setting up the custom value editor sample
Custom value editor sample details
Data sources for BOM domains
Setting up the data sources for BOM domains sample
Data sources for BOM domains sample details
Decision table management by using APIs
Setting up the decision table management by using APIs sample
Decision table management by using APIs sample details
Web authoring application
Setting up the web authoring application sample
Web authoring application sample details
Business rule management extensions for Decision Center
Automated decision service test and deployment
Setting up the automated decision service test and deployment sample
Automated decision service test and deployment sample details
Test and simulation customization
Setting up the test and simulation customization sample
Test and simulation customization details
Change notification
Setting up the change notification sample
Change notification sample details
Permission management
Setting up the permission management sample
Permission management sample details
Remote connection for querying
Setting up the remote connection for querying sample
Remote connection for querying sample details
Webhook notification
Setting up the webhook notification sample
Webhook notification details
Rule model property extensions
Setting up the rule model property extensions sample
Rule model property extensions sample details
REST API in Java
REST API in Java sample details
Storing and synchronizing rules
Why synchronize?
Sharing repositories between user profiles
Synchronization architecture
Branches and releases in synchronization
Guidelines for synchronizing BOM changes
Decision Center security in synchronization
Synchronizing from Rule Designer
Synchronization commands in Rule Designer
Publishing decision services to Decision Center
Adding a dependent project to a decision service
Publishing projects to Decision Center
Creating projects from Decision Center
Use of Compare in synchronization
Synchronization performance
Synchronization and source code control
Synchronizing by using Ant tasks
Rule project items
Authoring and managing rules
Key features
Introducing the Business console
Becoming familiar with the Business console
Identifying a set of rules
Searching for rules and folders
(Deprecated) Following streams and posting comments
Accessibility
Managing decision services
Decision services
Using AI-generated decision services
Managing branches
What are branches
Snapshots
Merging branches
Managing decision service branches
Deleting and recovering elements in branches
Generating a project report
Using governance with decision services
Governance principles
Managing changes with the decision governance framework
Decision artifacts
Action rules
How action rules work
Rule variables
Types of rule variables
Rule conditions
Conditions that compare business terms and values
Conditions that test for existence
Conditions that test set membership
Combinations of conditions
Condition negation
Rule actions
Dependency of rule actions on rule variables
Building rules using the Intellirule editor
Overview: Intellirule rule editor
Creating rule parts
Using punctuation to clarify rules
Setting completion menu options
Highlighting and correcting errors
Decision tables
How decision tables work
Decision tables
Columns
Rows and cells
Preconditions
Previewing decision tables
Locking table properties
Decision table editor
Keyboard shortcuts
Columns
Rows
Preconditions
Table cells
Errors and warnings
Row ordering
Transferring data to and from Excel
Ruleflows
Overview: Ruleflows
Creating a ruleflow
Configuring ruleflow properties
Decision operations
Defining ruleset variables
Dynamic domains
Updating domains from an Excel file
Updating domains from an external domain provider
Versions and history
Versioning in decision services
Viewing the timeline of a release or activity
Viewing the history of a decision artifact
Comparing versions of decision artifacts
Restoring a version of a decision artifact
Technical rules
Functions
Rule verification
Rule properties
Tags for rule artifacts
Overriding rules
Locking and unlocking decision artifacts and folders
Using queries
Query conditions
Query actions
Creating and running a query
Testing sets of rules in the Business console
Testing in the Business console
Understanding the reports
Excel scenario files
Simulating business application results
Overview: Simulations in the Business console
Workflow to create and run simulations
Deploying from the Business console
Deployment configurations
Redeploying
Version policies
Administering projects from the Business console
Setting project security
Managing servers
Diagnostics
Configuration settings
Decision Center settings
Business console settings
Custom settings
Build settings
Exporting or importing the current project
Setting up project dependencies
Tests and simulations for business rules
Generating Excel scenario files for the decision engine
Setting up custom data providers
Creating custom KPIs
Parallel processing
Deploying rules
Deploying from the Business console
Deployment configurations
Version policies
XOM deployment from Decision Center
Deploying decision services by using Ant tasks
Embedded managed Java XOM in Decision Center
Administrating
Opening the Decision Center Business console
Security using authentication and permissions
Security
Authentication
Permission management
Administering the Decision Center database
Creating the database schema and uploading message files
Create the database schema and upload message files by using REST API
Create the database schema and upload message files by using Ant tasks
Creating the schema by using a step-by-step sequence
Creating the database schema script
Executing the database schema script
Uploading the database schema extension
Removing a database schema
Setting the persistence locale
Setting configuration parameters
(Deprecated) Archiving the Decision Center database
Cleaning up the repository
Compacting Decision Center sequences
Erasing a project from a database
Copying projects to a new instance of Decision Center with full history
Freezing a project
Managing users from Decision Center
Enabling users and groups
Managing users and groups from the Business console
Managing users in LDAP
Importing users and groups from LDAP directories
Establishing an LDAP connection in the Business console
Configuring LDAP access for Decision Center
Managing users in SCIM
Setting up SCIM connections
Establishing an SCIM connection in the Business console
Importing users and groups by using SCIM
Creating users, groups and roles by using REST API
Managing users with Ant tasks
Creating users and groups by using Ant
Establishing an LDAP connection by using Ant tasks
Using the Decision Center Ant tasks
Setting up the Ant tasks environment
Repackaging the Decision Center archive
Configuring Decision Center with a configuration file
Configuring the search function of the Business console
Improving the performance of Decision Center
Customizing
Customizing the Business console interface
Defining extension points
Adding tabs and buttons
Disabling export and report tabs and commands
Adding a custom property editor
Defining a Spring controller
Setting up webhook notifications
Customizing the backend
Implementing the session controller
Integrating dynamic domain custom providers
Creating rule model add-on services
Associating a custom editor with a property
Creating property callbacks
Computing initial values for properties
Creating handlers for extractable properties
Integrating business rule management extensions
Integrating callbacks on properties
Integrating initial values for properties
Integrating extractable property handlers
Integrating query extensions
Integrating a custom ruleset extractor validator
Integrating rule authoring extensions
Integrating a value descriptor
Implementing a value editor
Integrating a value translator
Integrating a value info
Integrating a value provider
Integrating a value checker
Configuring a custom locale
Customizing the rule model
Rule model
Rule model extensions
Custom rule model class
Extended properties
Annotations
Rule model annotations
Rule model API
Rule model API for Rule Designer
Creating rule model extensions
Creating extension model and extension data files
Creating an extension model file for rule artifacts
Creating an extension data file for rule artifacts
Integrating a rule model extension file
Updating database schemas with REST API
Adding properties to rule model elements
Creating a new rule model class
Hiding a rule model class
Creating an enumeration property
Creating a Struct property
Creating a hierarchical property
Defining a default value for a property
Formatting date properties in model extensions
Using the Decision Center API
Database schema
Tables for standard features
Reference
Decision Center API
Decision Center REST API
Overview
Applying an interchange file
Decision Center API
Decision Center assets
Decision Center parameters
Messages
Troubleshooting and support
General
Identifying problems
Online support and tuning resources
Resolving a string issue in tests and simulations
Wrong class loading sequence
Troubleshooting on Tomcat
Setting the Java logging level
Providing more memory on Tomcat
Troubleshooting on JBoss
Enabling tests and simulations on JBoss
Setting the Java logging level
Providing more memory on JBoss
Troubleshooting the ODM event emitter
Rule Designer
Rule Designer logging
Ruleset archive errors
Upgrading to 9.x changes the format of BOM files
Resolving a B2X error for a correctly defined attribute or method
Resolving class not found exception during execution of a ruleset with decision engine
Rule Execution Server
Finding the cause of an improper Rule Execution Server configuration
Tuning the Decision Runner web application
Tuning the Rule Execution Server logging level
Determining the cause of a performance issue
Resolving slow first execution of a ruleset
JDBC not bound
Fixing a memory leak from using the HTDS REST API with JSON parameters
Limitations on OpenAPI specifications and tools
Limitation of the default maximum file size for deploying a RuleApp archive
Troubleshooting on the Liberty profile server
Setting the Java logging level
Decision Center
Collecting information about Decision Center
Enabling JDK logging in Decision Center
Displaying a hostname for Decision Center
Enabling JSON logging of Decision Center events
Too many open cursors in an Oracle database
Resolving a return code issue with Liberty server
Wrong class loading sequence
Providing more memory on Tomcat
Providing more memory on JBoss
Enabling JDK logging during the synchronization process
Fixing performance issues due to outdated database statistics
Glossary
A
B
C
D
E
F
G
H
I
J
K
M
N
O
P
Q
R
S
T
U
V
W
X
Operational Decision Manager on Certified Kubernetes 9.6.0
Overview
Introduction
Understanding enterprise workloads and services
Transition from physical to virtual servers
Licensing and metering
Reporting license usage to IBM Software Central
Online mode configuration
Offline mode (air-gapped environments)
Decision features not included
ODM for developers (ibm-odm-dev)
ODM for production (ibm-odm-prod)
Installing ODM charts on Certified Kubernetes
Prerequisites
System requirements
Installing ODM for production
Preparing to install Operational Decision Manager
Customizing ODM for production
Customizing your Liberty configuration
Creating dedicated runtime pods for specific rulesets
Configuring dedicated runtime pods
Ruleset path format
Accessing the Dedicated Runtime Service
Implementation details
Custom configuration references
Best practices and troubleshooting
Defining scripts for container starts and stops
Defining the security certificate
Collecting and sending usage metrics
Reporting usage metrics with IBM Usage Metering Service
Installing metering
Automatic data transmission
Uploading usage metrics to IBM Software Central
Disabling metering
Importing the certificate of an external service
Configuring user access
User roles and groups
Configuring user access with OpenID
Configuring user access without OpenID
Optional user access and Liberty configurations
Synchronizing users and groups in Decision Center
Configuring the database
Configuring the internal database
Configuring an external database
Configuring a custom external database
Preparing for Decision Center data migration
Optimizing the execution unit (XU)
Emitting runtime events
Configuring for Apache Kafka
Configuring the event emitter
Tuning and disabling the event emitter
Configuring for IBM Business Automation Insights
Configuring the Decision Center Business console
Customizing Decision Server
Customizing new Decision Server components
Customizing existing Decision Server components
Decision Server parameter properties
Customizing Decision Center
Customizing Decision Runner
Configuring multi-zone support
Configuring topology spread constraints on Operational Decision Manager pods
Configuring custom pod anti-affinity on Operational Decision Manager pods
Scheduling Operational Decision Manager pods onto tainted nodes
Configuring pod disruption budget on ODM deployments
Installing a Helm release of ODM for production
Completing post-deployment tasks
Configuring external access
Performing an air gap installation
Setting up a host to mirror images to a private registry
Setting environment variables and downloading CASE files
Mirroring images to a private registry
Option 1: Mirroring images to a private container registry with a bastion server
Option 2: Mirroring images to a private registry by a file system
Installing Operational Decision Manager
Setting up a repeatable mirroring process
Deploying to a managed Kubernetes service
Upgrading ODM releases on Certified Kubernetes
ODM and Helm chart versions
Rolling updates for ODM deployments
Rolling back the helm chart
Moving from on premises to Certified Kubernetes
Assessing your readiness
Preparing to move
Cleaning Rule Execution Server data
Preparing for the Decision Center data export
Installing containerized ODM
Migrating your LDAP connection
Migrating your database
Moving your persisted data
Moving Rule Execution Server data
Moving Decision Center data
Managing ODM deployments on Certified Kubernetes
Updating the user registry
Scaling deployments
Scaling manually
Autoscaling
Customizing log levels
(Deprecated) Customizing the Decision Center Business console
Customizing a Decision Center time zone
Persisting the Decision Center ruleset cache
Updating Kubernetes deployments with interim fixes
Installing Rule Designer
Installing the ready-to-use Rule Designer
Installing Rule Designer online
Installing Rule Designer offline
Selecting a display mode
Importing a security certificate in Rule Designer
Getting started tutorial and samples
Publishing decision services to Decision Center
Deploying decision services from Decision Center
Calling decision services with the REST API
Accessing Decision Center remotely from a Java client, and running Decision Center Ant tasks
Generating a JSON web token for a client assertion
Automating project builds with the Build Command
Setting up custom data providers
Troubleshooting
Reference
ODM for developers configuration parameters
Production parameters
LDAP configuration