404
+ +Page not found
+ + +'+ escapeHtml(title) + '
' + escapeHtml(summary) +'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/js/html5shiv.min.js b/js/html5shiv.min.js
new file mode 100644
index 0000000..1a01c94
--- /dev/null
+++ b/js/html5shiv.min.js
@@ -0,0 +1,4 @@
+/**
+* @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
+*/
+!function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=t.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=t.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),t.elements=c+" "+a,j(b)}function f(a){var b=s[a[q]];return b||(b={},r++,a[q]=r,s[r]=b),b}function g(a,c,d){if(c||(c=b),l)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():p.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||o.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),l)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return t.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(t,b.frag)}function j(a){a||(a=b);var d=f(a);return!t.shivCSS||k||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),l||i(a,d),a}var k,l,m="3.7.3",n=a.html5||{},o=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,p=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,q="_html5shiv",r=0,s={};!function(){try{var a=b.createElement("a");a.innerHTML="
+
+
+
+
+
+
+
+
+
+
+ Welcome to MAS Performance Wiki
+
+
+Info
+-
+
- This site will be updated periodically. More topics will be added soon. +
- Lab benchmarks are not published, but can be shared upon request, with completion of an NDA. +
This site provides best practices, sizing and troubleshooting guidelines to improve the performance of IBM Maximo Application Suite (MAS).
+Maximo 7.x Best Practices are also available on the site. Most DB configurations in the best practice are still applicable to MAS Manage app.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ AWS
+Instance Type
+There are many instance types available in AWS. Based on the benchmark, recommend M5, M6 instances (e.g.M5.4xlarge) as master or worker nodes and P3, P4 as GPU nodes.
+
+
+Note
+-
+
- Depending on the regions, some instances may not be available. Use AWS Pricing Calculator to check the instance availability and cost. +
- g4dn can be used as GPU node for test/dev env, but not recommended for production env. +
- If the application requires a good network performance, check Amazon EC2 instance network bandwidth site for more details. For production env, an instance with 10GB ethernet is recommended. +
Classic Load Balancer Idle Timeout
+Each OCP cluster creates 1 class load balancer and 2 network load balancers in AWS. AWS classic load balancer has a default idle time 60 seconds. In some cases, this value is not enough for a long time transaction (e.g. asset health check notebook). Consider to adjust this value to what the application needs (e.g. 300 seconds).
+Also, monitoring classic load-balance performance is strongly recommend, particularly with IoT related app. (Note: Surge Queue Length's defaults to a hardcoded limit of 1024. When queue is fully, the tcp handshake will fail)
+Amazon DocumentDB
+DocumentDB is a fully managed MongoDB compatibility database. It can be used by both IBM Suite License Service (SLS) and MAS Core. However, there are functional differences between DocumentDB and MongoDB. Check this link for more details.
+Note: When using DocumentDB, it requires to set RetryWrite=false in SLS and Suite CRs.
Amazon MSK
+MAS supports MSK which is a fully managed apache Kafka service.
+
+
+Note
+-
+
- monitor MSK performance via CloudWatch is strongly recommended. Key metrics include Disk usage by broker, CPU (User) usage by broker, Active Controller Count, Network RX packets by broker, Network TX packets by broker. +
- define an appropriate config for Kafka, MSK and topics. e.g. retention.ms, retention.bytes, partitions and replics to support the workload. +
AWS Storage
+EBS storages like gp2, gp3 are supported by OCP in AWS. Note: EBS storage is ReadWriteOnce. The volume can be mounted as read-write by a single node. io1 and io2 are SSD-based EBS that provides the higher performance. Check Amazon EBS volume types for extra info like throughput, tuning and cost.
+Below is a sample yaml to create io1 storageclass with 100 iopsPerGB.
+kind: StorageClass
+apiVersion: storage.k8s.io/v1
+metadata:
+ name: io1
+provisioner: kubernetes.io/aws-ebs
+parameters:
+ encrypted: 'true'
+ iopsPerGB: '100'
+ type: io1
+reclaimPolicy: Delete
+allowVolumeExpansion: true
+volumeBindingMode: Immediate
+EFS Storage can be used as ReadWriteMany storageclass. EFS has different metered throughput modes.
+-
+
- Bursting Throughput mode is the default. It is inexpensive, but does NOT perform well if all burst credits are used. Monitor BurstCreditBalance metric in CloudWatch. +
- Provisioned Throughput mode is relatively expensive. It can drive up to 3 GiBps for read operations and 1 GiBps for write operations per file system +
- More info can be found at Amazon EFS performance +
Self-managed OCP vs AWS ROSA
+A self-managed OCP Cluster can be created by the installer cli tool that supports both IPI and UPI mode. It requires self maintenance and upgrades. Alternatively, ROSA is a managed Red Hat OpenShift Service. Each ROSA cluster comes with a fully managed control plane and compute nodes. Installation, management, maintenance, and upgrades are performed by Red Hat site reliability engineers (SRE) with joint Red Hat and Amazon support.
+ +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/azure/bestpractice/index.html b/mas/azure/bestpractice/index.html
new file mode 100644
index 0000000..14d1557
--- /dev/null
+++ b/mas/azure/bestpractice/index.html
@@ -0,0 +1,213 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Azure
+Azure Storage
+For OCP cluster, it recommends Premium File Storage, because MAS and its components need RWX (Read/Write/Many permission) storage to support a certain level high availability as well as doclink, jms storage…
+For External DB VM, it recommends a high-performance storage like Premium SSD or v2 or Ultra Disk. More performance metric can be found in https://learn.microsoft.com/en-us/azure/virtual-machines/disks-types.
+ +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/core/bestpractice/index.html b/mas/core/bestpractice/index.html
new file mode 100644
index 0000000..229738b
--- /dev/null
+++ b/mas/core/bestpractice/index.html
@@ -0,0 +1,503 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MAS Core
+The MAS core namespace contains several important services required for user login and authentication, application management, MAS adoption metrics, licensing, etc. To understand the insight of each service/pod functionality in MAS core, check MAS Pods Explained .
+Scaling MAS core for large number of concurrent users
+The following are the key components/dependencies that require scaling as the number of concurrent MAS users grows.
+-
+
- MongoDB (used extensively by coreidp, api-licensing, adoptionusage, and other MAS/SLS microservices) +
- MAS core namespace:
-
+
- coreidp pods +
- licencing-mediator pods +
- coreapi pods (if users directly login to a MAS application, bypassing the Suite navigator page, this decreases the load on coreapi pods) +
+ - SLS namespace:
-
+
- api-licensing pods +
+ - k8s apiserver pods (coreapi pods issue k8s api calls to retrieve information from MAS application CRs, configmaps, etc.) +
+
+Caveat
+The scaling guidance described below is provided from lab benchmark testing and may vary based on the differences in workload, environment, or configuration settings.
+MongoDB
+MongoDB is a crucial dependency for MAS core services, if not scaled properly MongoDB can quickly become bottleneck as the number of concurrent users increases. A common symptom of an undersized MongoDB cluster is liveness probe timeouts and pod restarts of the MAS core services which depend on MongoDB (e.g. coreidp).
+For useful MongoDB troubleshooting commands see MongoDB Troubleshooting
+Key MongoDB metrics to monitor
+The following MongoDB metrics are important to monitor
+-
+
- Memory utilization: by default MongoDB will attempt to cache the active data set in memory (in the WiredTiger cache). If there are a large number of cache evictions or the mongod servers are oomkilled these can be indicators that the memory allocation is too small. Consider increasing the memory allocated to mongod server. +
- CPU utilization: check that the mongod servers have not reached their allocated cpu limit +
- Average read/write latency: average read and write latency should be under 50 milliseconds. If not it could be due to an undersized MongoDB cluster. Check that the MongoDB cluster has sufficient memory allocation and check disk performance. +
- Lock waiters: a large number of lock waiters indicates contention on collections/documents in MongoDB +
+
+Tip
+When using the ibm.mas_devops collection to install MAS you can optionally install Grafana with the cluster_monitoring ansible role. Once Grafana is installed via the cluster_monitoring ansible role you can then install MongoDB using the mongodb ansible role. The mongodb ansible role includes a Grafana dashboard for monitoring the MongoDB cluster.
+If your using a MongoDB cluster hosted by a cloud provider uses the monitoring dashboards provided by the cloud provider.
+Important MongoDB databases and collections
+The following databases and collections in MongoDB are accessed frequently during user login and authentication.
+-
+
- Database: mas_{{mas-instance-id}}_core
-
+
- Collection: User (user lookup during authentication) +
- Collection: OauthToken (token creation/deletion) +
+ - Database: {{sls-id}}_sls_licensing
-
+
- Collection: licenses (checkin/checkout licenses) +
+ - Database: mas_{{mas-instance-id}}_adoptionusage
-
+
- Collection: users (daily adoption usage statistics) +
- Collection: users_hourly (hourly adoption usage statistics) +
+
Scaling MongoDB community
+The table below provides some general guidance on scaling MongoDB based on number of concurrent users and login rate. To scale MongoDB community edition you should specify the desired cpu/mem limits in the MongoDBCommunity CR.
+spec:
+ statefulset:
+ spec:
+ template:
+ spec:
+ containers:
+ - name: mongod
+ resources:
+ limits:
+ cpu: <cpu limit>
+ memory: <mem limit>
+| Login rate (logins/minute) | +MongoDB CPU limit | +MongoDB Memory limit (GB) | +
|---|---|---|
| 75 | +2 | +4 | +
| 150 | +2 | +4 | +
| 300 | +4 | +8 | +
| 600 | +6 | +12 | +
| 1200 | +8 | +16 | +
Scaling coreidp service (MAS core namespace)
+The table below provides some general guidance on scaling the coreidp service based on number of concurrent users and login rate. To scale the coreidp service use the podTemplates workload customization feature in MAS.
+| Login rate (logins/minute) | +coreidp replicas | +coreidp CPU limit | +coreidp Memory limit (GB) | +
|---|---|---|---|
| 75 | +1 | +6 | +1 | +
| 150 | +1 | +6 | +1 | +
| 300 | +1 | +6 | +1 | +
| 600 | +2 | +6 | +2 | +
| 1200 | +4 | +6 | +3 | +
Scaling licensing-mediator service (MAS core namespace)
+The table below provides some general guidance on scaling the licensing-mediator service based on number of concurrent users and login rate. The coreidp service calls the licensing-mediator service which in turn calls the api-licensing service in the SLS namespace for license checkin/checkout operations. To scale the licensing-mediator service use the podTemplates workload customization feature in MAS.
+| Login rate (logins/minute) | +licensing-mediator replicas | +licensing-mediator CPU limit | +licensing-mediator Memory limit (GB) | +
|---|---|---|---|
| 75 | +1 | +1 | +1 | +
| 150 | +1 | +1 | +1 | +
| 300 | +2 | +2 | +1 | +
| 600 | +4 | +3 | +1 | +
| 1200 | +6 | +3 | +1 | +
Scaling api-licensing service (SLS namespace)
+The table below provides some general guidance on scaling the api-licensing service based on number of concurrent users and login rate. To scale the api-licensing service use the podTemplates workload customization feature in MAS.
+| Login rate (logins/minute) | +api-licensing replicas | +api-licensing CPU limit | +api-licensing Memory limit (GB) | +
|---|---|---|---|
| 75 | +1 | +1 | +2 | +
| 150 | +1 | +2 | +2 | +
| 300 | +2 | +2 | +2 | +
| 600 | +2 | +2 | +2 | +
| 1200 | +2 | +2 | +2 | +
Scaling coreapi service (MAS core namespace)
+The table below provides some general guidance on scaling the coreapi service based on number of concurrent users and login rate. To scale the coreapi service use the podTemplates workload customization feature in MAS.
+| Login rate (logins/minute) | +coreapi replicas | +coreapi CPU limit | +coreapi Memory limit (GB) | +
|---|---|---|---|
| 75 | +3 | +1 | +2 | +
| 150 | +3 | +1 | +2 | +
| 300 | +3 | +1 | +2 | +
| 600 | +3 | +2 | +2 | +
| 1200 | +3 | +3 | +2 | +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/ibmcloud/bestpractice/index.html b/mas/ibmcloud/bestpractice/index.html
new file mode 100644
index 0000000..6549dfd
--- /dev/null
+++ b/mas/ibmcloud/bestpractice/index.html
@@ -0,0 +1,254 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ IBM Cloud
+IBM Storage
+IBM Cloud provides both block and file storages for OCP. Both storages support ReadWriteMany access. If the app requires a high-performance disks, consider to setup custom performance storageclass as blow:
+block storage sample yaml
+allowVolumeExpansion: true
+apiVersion: storage.k8s.io/v1
+kind: StorageClass
+metadata:
+ name: block100p
+parameters:
+ billingType: hourly
+ classVersion: "2"
+ fsType: ext4
+ sizeIOPSRange: |-
+ [20-1999]Gi:[100-100]
+ type: Performance
+provisioner: ibm.io/ibmc-block
+reclaimPolicy: Delete
+volumeBindingMode: WaitForFirstConsumer
+file storage sample yaml
+allowVolumeExpansion: true
+apiVersion: storage.k8s.io/v1
+kind: StorageClass
+metadata:
+ name: file100p
+parameters:
+ billingType: hourly
+ classVersion: "2"
+ fsType: ext4
+ sizeIOPSRange: |-
+ [20-1999]Gi:[100-100]
+ type: Performance
+provisioner: ibm.io/ibmc-file
+reclaimPolicy: Delete
+volumeBindingMode: WaitForFirstConsumer
+IBM External Load Balancer
+If the built-in ingress load balancer in OCP is unable to scale to handle with "large" workloads (100K+ concurrent device connections), consider to provision an instance of IBM cloud NLB2.0 (IPVS/KeepAlived) load balancer.
+IBM ROKS
+IBM ROKS is a managed Red Hat OpenShift Service in IBM Cloud. Each ROKS cluster comes with a fully managed control plane and compute nodes. Installation, management, maintenance, and upgrades are performed by Red Hat site reliability engineers (SRE) with joint Red Hat and IBM Cloud support.
+ +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/iot/bestpractice/index.html b/mas/iot/bestpractice/index.html
new file mode 100644
index 0000000..f556215
--- /dev/null
+++ b/mas/iot/bestpractice/index.html
@@ -0,0 +1,321 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MAS IoT
+MQTT vs HTTP Messaging
+The MQTT protocol is the preferred messaging protocol for data ingest in to the MAS IoT service. HTTP messaging support was added to MAS IoT for low volume scenarios and is not designed to be used for message rates greater than 1K msgs/sec.
+MQTT message ingest rates are 2-3 orders of magnitude faster than HTTP. The primary reason being that HTTP messaging requires a TLS handshake and authentication on every message published. The authentication requires a database lookup for the device authentication token. As such, HTTP messaging puts a strain on the authentication service and the IoT database.
+In order to achieve high data ingest rates with MAS IoT service, use the MQTT protocol and keep the device connection open while publishing messages.
+Best practice messaging pattern
+MQTT CONNECT
+MQTT PUBLISH (in loop until all messages are published)
+Messaging Anti-pattern
+MQTT CONNECT
+MQTT PUBLISH
+MQTT DISCONNECT
+MQTT CONNECT
+MQTT PUBLISH
+MQTT DISCONNECT
+...
+Data Ingest rates, devices, and connections
+The MQTT service in MAS IoT was designed to handle many device connections, each publishing at low rates. As such, when designing a data ingest application for MAS IoT it should distribute the load over many MQTT devices or applications in order to maximize message rates. Single device or application connections will be throttled based on the IoT Fair use policy (see below).
+IoT Fair Use Policy
+IoT data ingest throttling limits are per device and are based on the device class (i.e. Device, Gateway, Application). These limits are in place to prevent DoS attacks from rogue (i.e. badly behaving) devices. The throttling limits do not scale with the MAS IoT deployment size. For more information on MAS IoT messaging quotas see https://www.ibm.com/docs/en/mapms/1_cloud?topic=features-quotas
+Messaging QoS
+The messaging QoS specified when publishing an MQTT message also has a strong impact on messaging rates.
+QoS in order of fastest to slowest:
+-
+
- QoS 0 - at most once (data loss possible, no message persistence or ACKs) +
- QoS 1 - at least once (duplicates are possible, messages persisted and ACKed) +
- QoS 2 - exactly once (application client required to maintain state, messages persisted and two phase commit between client/server) +
QoS >0 performance considerations
+-
+
- requires disk persistence in MAS IoT messaging components and therefore disk I/O performance becomes critical with QoS >0. +
- the MQTT specification provides a kind of protocol level flow control negotiation between client and server. The number of unacked messages allowed on the session is negotiated between client and server and if the client has no more available msg ids it must pause publishing until msg IDs become available. Msg IDs become available when messages ACKs are received. See MQTT spec for details: https://docs.oasis-open.org/mqtt/mqtt/v5.0/os/mqtt-v5.0-os.html#_QoS_1:_At +
Summary of factors that influence data ingestion rate
+-
+
- Choice of messaging protocol: MQTT (high volume) vs HTTP (low volume) +
- Messaging Pattern: do NOT close MQTT sessions after each message published. leave connections open. +
- Number of devices: Higher message rates are possible when the load is distributed over more connections +
- Choice of device class: Fair use quotas are based on device class (https://www.ibm.com/docs/en/mapms/1_cloud?topic=features-quotas)[https://www.ibm.com/docs/en/mapms/1_cloud?topic=features-quotas] +
- Choice of QoS: high levels of messaging guarantees come with higher costs +
IoT Deployment
+-
+
- IoT CRD defines 3 default size deployments: dev, small, medium that controls the default settings for pod replics, cpu and memory. For production, medium is required.
+Sample yaml for medium deployment in IoT CR
+
apiVersion: iot.ibm.com/v1 +kind: IoT +metadata: + name: masinst1 + namespace: mas-masinst1-iot +spec: + bindings: + jdbc: system + kafka: system + mongo: system + settings: + deployment: + size: medium +
+ - If need to adjust the default setting for a deployment, go the iot-operator pod, then change the corresponding yaml files under
/opt/ansible/roles/<ibm-iot-operator>/varsfolder, e.g./opt/ansible/roles/ibm-iot-actions/vars/size_medium.yml
+
Connection and OpenShift Ingress Controllers
+Openshift HAProxy supports 20k connection per pod. The total connection determinants how many end devices can connect to IoT MSProxy.
+-
+
- By default, IBM ROKS deploys 3 router members that supports 3x20k = 60K connection +
- By default, AWS ROSA deploys 2 router members that supports 2x20k = 40K connection
-
+
- use the below command to scale up to 3 router members:
+
oc patch -n openshift-ingress-operator ingresscontroller/default --patch '{"spec":{"replicas": 3}}' --type=merge
+
+ - use the below command to scale up to 3 router members:
+
Kafka
+IoT uses Kafka to process the messages. Follow the Kafka Configuration Reference to configure best value for Kafka/Topics retention.ms, retention.bytes, partitions, replics to support the workload.
AWS MSK
+-
+
- configuration details can be found at https://docs.aws.amazon.com/msk/latest/developerguide/msk-default-configuration.html +
- monitoring MSK is strongly recommended +
- monitoring classic load-balance is strongly recommend +
Message Rate and Ethernet Network Bandwidth
+Depending on the cloud providers, worker node instance has different network bandwidth. It determines how fast the end devices can send the request. Message rate is limited by the message size and the bandwidth of ethernet network. To achieve higher rates and/or larger messages it will require a 10GB ethernet. The network bandwidth also impacts the response latency. The higher bandwidth, the lower latency.
+Below deployment configurations are recommended as starting value with medium and large workload.
+-
+
- MSProxy - 4 MSProxies with 1 CPU and 4GB +
- MessageGateWay - 1 MGW 6 CPUs and 16GB along with 4 TcpIop threads +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/manage-industry-solutions/ong-hse/bestpractice/index.html b/mas/manage-industry-solutions/ong-hse/bestpractice/index.html
new file mode 100644
index 0000000..4d5c1b8
--- /dev/null
+++ b/mas/manage-industry-solutions/ong-hse/bestpractice/index.html
@@ -0,0 +1,312 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MAS Manage Oil and Gas/HSE
+Best Practice for Performance
+-
+
- Archive or clean historical records of "Permit to Work", "Isolation Certificate", "Work Order" and "Operator Log/LogEntry" will help a lot on performance.
+
+ - Adding below indexes which we identified in internal benchmark test will help a lot on performance.
+ Please do remember to update table statistics after adding any new index, since new index will only be effective after updating table statistics.
+
Indexes Identified in Internal Benchmark Test
+| Table Name | +Columns | +Comments | +
|---|---|---|
| plusgpermitwork | +"ptwclass" ASC,"siteid" ASC,"orgid" ASC,"permitworknum" ASC | ++ |
| plusgpermitwork | +"ptwclass" ASC,"status" ASC,"plusgpertypeid" ASC,"permitworknum" ASC | ++ |
| plusgpermitwork | +"ptwclass" ASC | ++ |
| plusgpermitwork | +"status" ASC,"ptwclass" ASC,"description" ASC | ++ |
| plusgpertype | +"pertypenum" ASC,"plusgpertypeid" ASC | ++ |
| workorder | +"description" ASC | +Add it if search on description field, create as text index is better | +
| workorder | +"status" ASC,"historyflag" ASC,"istask" ASC,"wonum" ASC | +Add it if search on status field | +
| plusgoperaction | +"recordid" ASC,"class" ASC | ++ |
| plusgshftlogentry | +"recordkey" ASC,"orgid" ASC,"siteid" ASC,"createdate" ASC | ++ |
| plusgshiftlog | +"shiftnum" ASC,"isshiftlog" ASC,"startdate" ASC | ++ |
| plusgrelatedrec | +"relatedreckey" ASC,"relatedrecclass" ASC,"recordkey" ASC | ++ |
| plusgrelatedrec | +"recordkey" ASC,"class" ASC,"relatedrecclass" ASC | ++ |
| plusgincperson | +"ticketid" ASC | ++ |
| maxsession | +"issystem" ASC, "userid" ASC, "clienthost" ASC | ++ |
| ticket | +"globalticketid" ASC,"globalticketclass" ASC | ++ |
| report | +"reportname" ASC,"appname" ASC,"reportnum" ASC,"runtype" ASC,"userid" ASC | ++ |
| reportrunqueue | +"running" ASC,"priority" ASC,"submittime" DESC | ++ |
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/manage-industry-solutions/transportation/bestpractice/index.html b/mas/manage-industry-solutions/transportation/bestpractice/index.html
new file mode 100644
index 0000000..cf729d8
--- /dev/null
+++ b/mas/manage-industry-solutions/transportation/bestpractice/index.html
@@ -0,0 +1,495 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MAS Manage Transportation
+Best Practice for Performance
+-
+
- Due to some Transportation applications execute SQLs contain "Like" clause, turn off DB2 Statement Concentrator can make CPU utilization much lower on database server (db2 update db cfg for database_name using stmt_conc off).
+
+ - Adding below indexes which we identified in internal benchmark test will help a lot on performance.
+ If not specified, all columns are ASC by default.
+ Please do remember to update table statistics after adding any new index, since new index will only be effective after updating table statistics.
+
Indexes Identified in Internal Benchmark Test
+| Table Name | +Columns | +
|---|---|
| PLUSTWARRTRANS | +CONTRACTTYPE,CLAIMID,ASSETNUM,CONTRACTNUM,SITEID | +
| PLUSTWARRTRANS | +CONTRACTTYPE,CLAIMID,TRANSDATE,PLUSTWARRTRANSID | +
| maxuser | +status,userid | +
| logintracking | +"userid" ASC,"attemptresult" ASC,"attemptdate" DESC | +
| craftrate | +orgid | +
| SYNONYMDOMAIN | +MAXVALUE,DOMAINID,VALUE | +
| CONTLINEASSET | +"PLUSTNEWEXTENDEDREASON" ASC, "LOCATION" DESC | +
| CONTRACT | +CONTRACTTYPE,STATUS,ORGID,CONTRACTNUM | +
| LOCHIERARCHY | +LOCATION,SYSTEMID,SITEID,PARENT | +
| MULTIASSETLOCCI | +ISPRIMARY,RECORDKEY,WORKSITEID,RECORDCLASS | +
| PLUSTASSETALIAS | +ISACTIVE,ALIAS,PLUSTASSETALIASID,DESCRIPTION,ORGID,LANGCODE,ISDEFAULT,ISASSETNUM,HASLD,SITEID,ASSETNUM | +
| INVOICELINE | +PLUSTCONTRACTNUM,SITEID,INVOICELINENUM,INVOICENUM | +
| INVOICE | +INVOICENUM,SITEID,STATUS | +
| INVOICELINE | +INVOICENUM,SITEID,INVOICELINENUM | +
| INVOICECOST | +"INVOICENUM" ASC, "SITEID" ASC, "ASSETNUM" ASC, "INVOICELINENUM" ASC | +
| ASSET | +"ASSETNUM" ASC, "SITEID" ASC, "ASSETID" ASC | +
| inspectionform | +inspformnum,status,orgid | +
| inspectionresult | +"siteid" ASC, "referenceobject" ASC, "referenceobjectid" ASC | +
| PLUSTWARRTRANS | +"CONTRACTTYPE" ASC, "CLAIMID" ASC, "PLUSTWARRTRANSID" ASC | +
| propertydefault | +contracttypeid,orgid | +
| plustitemwarr | +itemnum,plustpos,orgid,assetid,matusetransid,plustitemwarrid | +
| plustitemwarrmtr | +plustitemwarrid | +
| plustassetalias | +assetnum,siteid,isdefault | +
| PLUSTWARRTRANS | +"CLAIMID" ASC, "SITEID" ASC | +
| countbookline | +itemnum,countbooknum,siteid | +
| countbookline | +countbooknum,siteid,orgid | +
| countbookline | +match,countbooknum,siteid,orgid | +
| countbookline | +recon,countbooknum,siteid,orgid | +
| countbookline | +physcnt,countbooknum,siteid,orgid | +
| countbook | +storeroom,countbooknum,siteid | +
| item | +itemsetid,itemnum | +
| warrantyasset | +contractnum,revisionnum,orgid,assetid | +
| contractline | +CONTRACTNUM,REVISIONNUM,ORGID,CONTRACTLINENUM,contracttype | +
| invbalances | +"PHYSCNTDATE" DESC, "SITEID" ASC, "ITEMNUM" ASC | +
| countbookline | +countbooknum,siteid,rotating,itemnum | +
| invbalances | +location,nextphycntdate | +
| inventory | +location,siteid,orgid,itemnum | +
| countbooksel | +countbooknum,siteid | +
| mafappdata | +ismobile,status | +
| asset | +assetnum,siteid,status,plustisconsist,plustalias,orgid | +
| plustassetalias | +assetnum,siteid,isactive | +
| invoicecost | +assetnum,siteid | +
| plustclaim | +orgid,contractnum,status | +
| plustclaim | +assetnum,siteid | +
| asset | +assetid,moved,plustisconsist,description | +
| invoice | +siteid,invoicenum,status,orgid | +
| wplabor | +wplaborid,orgid | +
| joblabor | +orgid,siteid,jobplanid,jptask | +
| workorder | +plustcmpnum,siteid,status | +
| plustitemwarr | +matusetransid | +
| contlineasset | +assetid,location,locationsite,warrantystartdate,warrantyenddate,contractnum | +
| CONTRACT | +contractnum,revisionnum,orgid,contracttype,status | +
| contlineasset | +assetid,orgid,plustfullcoverage,contractnum,revisionnum,contractlinenum | +
| plustwpserv | +wpservid,orgid | +
| plustwarrtrans | +matusetransid,covereditemnum | +
| contractline | +itemnum,conditioncode,linestatus | +
| warrantyline | +plustcoverservices,plustcovermaterials | +
| pm | +siteid,status,pmnum,assetnum | +
| workorder | +siteid,pmnum,status | +
| plustwpserv | +wonum,siteid | +
| plustwarrtrans | +servrectransid | +
| plustwarrtrans | +parentwonum,refwonum,claimid,siteid,linecost | +
| plustwpserv | +invoicenum,invoicesite | +
| invoice | +status,invoicenum,siteid | +
| maxvars | +varname,orgid,varvalue | +
| inspectionresult | +inspformnum,revision,orgid,siteid,status,asset,location,resultnum | +
| plustwpserv | +wonum,invoicenum,complete | +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/manage/bestpractice/index.html b/mas/manage/bestpractice/index.html
new file mode 100644
index 0000000..a1e2bcc
--- /dev/null
+++ b/mas/manage/bestpractice/index.html
@@ -0,0 +1,394 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MAS Manage
+At what point is it necessary to partition a MAS Manage workload across more than one MAS instance?
+A new MAS instance is required to run MAS Manage workloads at the point in which the DB server can no longer be scaled up. When the DB server can no longer be scaled up, the customer should plan to create a new MAS instance and move sites to the new MAS instance which will be using a new DB server.
+Maximo Transaction latency
+When describing Maximo transaction latency it is important to define the boundaries of what constitutes a standard or out-of-the-box Maximo transaction. The description below does just that.
+Terminology
+-
+
- CRUD refers to create, update, delete operations +
- MBO stands for Maximo Business Objects (which are hierarchical in nature) +
- Transaction latency is defined as the elapsed time between when the Maximo server receives the transaction request to the time when the Maximo server has sent the response. For UI users this also includes the elapsed time between when the Save button is clicked to when control is returned to the user. +
Definition of a transaction
+An out of the box Maximo transaction is expected to complete with a latency of 2 seconds or less, where a transaction is defined as the creation, update, or deletion of a single MBO, containing no more than one child object and with no attachments or binary data (blobs). Example include, but are not limited to:
+-
+
- Creation of a single WorkOrder object. This includes generation of the WorkOrderStatus and WorkOrderAncestor records. +
- Update of a single WorkOrder object. For example, changing states from Approved to Closed. +
- Deletion of a single WorkOrder object. +
Definition restrictions
+The following conditions are considered to be outside the scope of an out of the box Maximo transaction, and therefore do not fall under the 2 second latency characterization.
+-
+
- For UI initiated transactions this does not include latency incurred from downloading UI resources (e.g. js, css, png, jpg, etc.) +
- It applies to out of the box Maximo applications, but not customized applications or out of the box Maximo applications with automation scripts +
- It does not apply to UI initiated transactions with a large number of xhr requests (or portlets), for example the Maximo start center. Large here means greater than 2 xhr requests per page. Note, Maximo currently supports HTTP/1.1, so xhr requests initiated from a single user UI page are sequential, not concurrent. +
- It does not apply to customized saved queries. +
- It does not apply to bulk load requests. +
- It does not apply to report related transactions +
App Server
+MAS Manage has different bundle types e.g. All, UI, MEA, Report and CRON to configure app server. Adjust the resource settings like cpu, memory, replic to match the workload. The settings are in ManageWorkspaces CR. Below is the sample.
+apiVersion: apps.mas.ibm.com/v1
+kind: ManageWorkspace
+...
+spec:
+ settings:
+ deployment:
+ serverBundles:
+ - bundleType: mea
+ isDefault: false
+ isMobileTarget: false
+ isUserSyncTarget: true
+ name: mea
+ replica: 1
+ routeSubDomain: all
+ - bundleType: cron
+ isDefault: false
+ isMobileTarget: false
+ isUserSyncTarget: false
+ name: cron
+ replica: 1
+...
+spec:
+ settings:
+ resources:
+ manageAdmin:
+ limits:
+ cpu: '2'
+ memory: 4Gi
+ requests:
+ cpu: '0.2'
+ memory: 500Mi
+ serverBundles:
+ limits:
+ cpu: '6'
+ memory: 10Gi
+ requests:
+ cpu: '0.2'
+ memory: 1Gi
+Load-Balancer
+Lab test shows roundrobin has more stable and better performance than leastconn policy which is the default. Follow this link to update load balancer policy.
+Manage Pod Functionality
+Follow this link to understand the manage pod functionality.
+LTPA timeout
+Using IBM Maximo Application Suite (MAS), Manage users will receive an error message saying to reload the application after 2 hours, even while actively working. This 2-hour timeout default is when the LTPA token in Manage expires, and is redirecting the user back to the login page for MAS. Follow Updating LTPA timeout in Manage to increase the default value.
+WebSphere Liberty
+Due to the architecture change, Maximo 8.x (MAS Manage app) is deployed on WebSphere Liberty Base 21.0.0.5 with OpenJ9. As of WebSphere Liberty 18.0.0.1, the thread growth algorithm is enhanced to grow thread capacity more aggressively to react more rapidly to peak loads. For many environments, this autonomic tuning provided by the Open Liberty thread pool works well with no configuration or tuning by the operator. If necessary, you can adjust coreThreads and maxThreads value by tuning liberty.
Configure JVM options in Manage app
+Follow this link to configure JVM options
+DB
+Disk
+disk performance is critial for db performance. Recommend a storage or disk with
+-
+
- disk throughput: > 250 MB/s +
- IOPS: 10 IOPS/GB to 100 IOPS/GB (depending on volume size) +
To measure disk performance on Linux use the dd command. The sample command below measures disk performance of the data volume inside a db2 pod running in OCP
+
+CAUTION
+Make sure that ddtest filename is appended to the end of the data path or the dd command will wipe the db2 data directory.
[db2inst1@c-db2wh-manage-db2u-0 - Db2U bludata0]$ dd if=/dev/zero of=path_of_db2_data_directory/ddtest bs=128K count=8192
+8192+0 records in
+8192+0 records out
+1073741824 bytes (1.1 GB, 1.0 GiB) copied, 2.84314 s, 378 MB/s
+[db2inst1@c-db2wh-manage-db2u-0 - Db2U bludata0]$
+Network latency between app and db server
+Reducing network latency is key to optimizing performance. Confirm latency is below 50ms by conducting a ping test. For production env, strongly recommend keeping the latency below 10ms and having app and db server in the same network segment. In cloud deployment scenarios, ensure both the database and OpenShift cluster are located within the same region, with the possibility of being in the same availability zone (AZ). Utilize the ping command to evaluate and pinpoint latency issues.
+Large table optimization
+When optimizing large tables in the Manage app, it is recommended to transfer these tables to a dedicated tablespace on high-throughput disks, coupled with a dedicated buffer cache for enhanced performance. The speed of the disks and the availability of memory play crucial roles in this optimization strategy. Additionally, ensure that index statistics are regularly updated, and address any problematic queries to further optimize the system.
+DB - DB2/DB2wh
+DB2 Tuning in Maximo 7.6.x Best practice is applicable.
+
+
+IMPORTANT
+The containerized DB2U and DB2WH deployments do NOT support text search (Regular DB2 has text search).
+As a result, some queries may perform poorly on containerized DB2 relative to Oracle DB and SQL Server, which both support text search.
Searching records by Description on the list page is a typical scenario whose performance can benefit from text search capability of the database, especially if no other indexed attributes are included in the query.
+Adding a non-unique index on Description can help if an exact search can be made (Maximo search type = EXACT or user types is "=" before the search string, eg =Text) or the search can be done based on the beginning of the string (user types '%' at end of the string, eg Text%). If possible, adding other fields to the query (either by user typing them or as part of the default, where those attributes are part of an index can also help. In addition, adding Description to the end of one of these indexes can also show improvement.
+Highlights:
+-
+
- increase maxsequence cache to 50 +
- run runstats and/or reorg to update index periodically +
- separate system storage, user storage, backup storage, transaction logs storage, temporary tablespace storage on different disks if possible. +
- Use DB2 Performance Diagnosis to troubleshoot and tuning the db and SQL. +
- Manage requires row-organized tables. Check db2w db setting (by default it uses column based) and update the setting by
db2 update db cfg using DFT_TABLE_ORG ROW
+ - Manage does NOT support MMP or table partition in the current version, but consider to archive records over 1-year old. Optim is the one of the tools can be used for archiving. see this guide and this video for details. +
- Increase the concurrently running statements allowed for a DB2 application. This issue occcurs when loading a large amount of data via MIF or api call. See this link for the tuning. +
- storageclass
-
+
- for ibm cloud: performance(Custom) block storage with 100+ IOPS for data storage, block gold for system and block silver for backup +
- for aws cloud: if using EFS for db, consider Provisioned mode to have a constant throughput. For more disk options, see details in this page +
+ - For db2 registry (db2set):
-
+
- Set db2_workload=maximo. That makes db cfg variable WLM_ADMISSION_CTRL is set to NO +
- Do NOT change the default values for DB2_OVERRIDE_NUM_CPUS and DB2_OVERRIDE_THREADING_DEGREE. +
+ - Verify db2 db cfg variable WLM_ADMISSION_CTRL is set to NO +
- For db2ucluster CR
-
+
- Do NOT set db2 instance memory. The operator will automatically calculate it based on the container memory limit. +
- (Optional) for performance stability, set the same value to both container resource request and limit. +
+ - For db2 monitor switches
-
+
- The best practice is turn off all monitor switches except the Timestamp in dbm cfg. +
- If turn on monitor switches in dbm cfg, will cause monitor switches are turned on by default for all DB2 sessions, this will bring 5%-10% overhead on the overall database performance, depends on the workload and database server hardware spec. +So we should not turn on monitor switches in dbm cfg. +
- When we need to take DB2 monitor data, we should only turn on monitor switches in a specific session by the following command:
+ db2 update monitor switches using BUFFERPOOL on LOCK on SORT on STATEMENT on TIMESTAMP on TABLE on UOW on
+And turn off all monitor switches immediately after getting required monitor data by the following command:
+ db2 update monitor switches using BUFFERPOOL off LOCK off SORT off STATEMENT off TIMESTAMP off TABLE off UOW off
+
+
DB - Oracle
+-
+
- Maximo 7.6.x Best practice is applicable +
DB - MSSQL
+-
+
-
+
Maximo 7.6.x Best practice is applicable
+
+ -
+
additional settings for MSSQL Server 2019
+-
+
- compatibility level: if maximo db is upgraded from the old version and the performance degradation is observed after the upgrade, consider to set compatibility level to the old version to keep the execution plan same. +
- isolation level:
+
ALTER DATABASE <DB NAME> + SET ALLOW_SNAPSHOT_ISOLATION ON + + ALTER DATABASE <DB NAME> + SET READ_COMMITTED_SNAPSHOT ON +
+
+
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/manage/pccinfer-batchsize.png b/mas/manage/pccinfer-batchsize.png
new file mode 100644
index 0000000..3f38c81
Binary files /dev/null and b/mas/manage/pccinfer-batchsize.png differ
diff --git a/mas/manage/pccinfer-cpu.png b/mas/manage/pccinfer-cpu.png
new file mode 100644
index 0000000..5cd718c
Binary files /dev/null and b/mas/manage/pccinfer-cpu.png differ
diff --git a/mas/manage/pccinfer-memory.png b/mas/manage/pccinfer-memory.png
new file mode 100644
index 0000000..aa80c46
Binary files /dev/null and b/mas/manage/pccinfer-memory.png differ
diff --git a/mas/manage/pcctrain-cpu.png b/mas/manage/pcctrain-cpu.png
new file mode 100644
index 0000000..0849f0f
Binary files /dev/null and b/mas/manage/pcctrain-cpu.png differ
diff --git a/mas/manage/pcctrain-samples.png b/mas/manage/pcctrain-samples.png
new file mode 100644
index 0000000..92d8c7f
Binary files /dev/null and b/mas/manage/pcctrain-samples.png differ
diff --git a/mas/manage/woi-infer/index.html b/mas/manage/woi-infer/index.html
new file mode 100644
index 0000000..48627ec
--- /dev/null
+++ b/mas/manage/woi-infer/index.html
@@ -0,0 +1,223 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Work Order Intelligence Inferencing
+This was added to the MAS Manage application to assist users with problem code classification (PCC) for Work Orders. See the product documentation for more details.
+PCC model inferencing (batch mode from cron task)
+Inferencing is typically run more frequently than training, but is less resource intensive. By default, MAS Manage is configured with a single instance of the AIINFJOB cron task. This is recommended for most workloads.
+The predictor pod where inferencing/prediction occurs receives a batch of Work Orders to be inferenced from the MAS Manage cron pod running the AIINFJOB cron task. The batch size (or page size, defined on the MXAPIWODETAIL object structure query template) is the best way to control the rate at which Work Orders are inferenced. In the graph below you can see how the total time to inference 100K work orders is influenced by the batch size. With a batch size of 500 Work Orders/request and a 30 second interval for the AIINFJOB cron task 100K work orders were inferenced in approximately 1.6 hours. Compared to a batch size of 10 WO/request which took 83 hours.
+
+
+Important
+The recommended batch size is 500 Work Orders/request and the recommended interval for the AIINFJOB cron task is 30 seconds.
+
PCC model inferencing required resources (batch mode from cron task)
+The graphs below show the CPU and memory resource utilization of the predictor pod based on the batch size. As you can see, the CPU utilization of the predictor pod increases with the batch size, but the memory utilization remains fairly consistent (i.e. between 4GB - 5GB)
+
PCC model inferencing: batch cron processing vs on-demand single inference
+For bulk inferencing of large numbers of Work Orders it is recommended to use the AIINFJOB cron task. However, UI users can also request problem code inferencing on a single work order. In this case the predictor pod will receive a single work order and as a result the overhead of processing a single work order is much higher. For example, to inference a batch of 10 or more work orders will result in an average inferencing time of 20 milliseconds per work order in the predictor pod, but the inference time for a single work order from the UI is about 120 milliseconds (in the predictor pod). The total time including the MAS Manage API request is about 750 milliseconds. It is therefore much more efficient to inference large numbers of work orders asynchronously using the AIINFJOB cron task and a page size of 500. In other words, don't use the API from a script.
+ +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/manage/woi-train/index.html b/mas/manage/woi-train/index.html
new file mode 100644
index 0000000..2e97a4c
--- /dev/null
+++ b/mas/manage/woi-train/index.html
@@ -0,0 +1,226 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Work Order Intelligence Training
+This was added to the MAS Manage application to assist users with problem code classification (PCC) for Work Orders. See the product documentation for more details.
+PCC model training required resources
+Model training is resource intensive. For this reason there is a limit of one active model training per MAS Manage instance.
+A single model training requires at least 8GB of memory. The pipeline pod, where model training occurs, will allocate a number of busy processes equal to the number of CPU on the worker node where the pod is scheduled. At the time of this writing there is no CPU limit set for the pipeline pod, so it will consume as much CPU resources as are available on the worker node where it is scheduled. In general, the more CPU is available to the pipeline pod the faster training time will go.
+The three data points on the graph below were taken on a 16 CPU worker node. In the tests below a cpu limit was placed on the pipeline pod (not the default, i.e. by default the pipeline pod does not have specified limits). As you can see the training time with an 8 CPU limit was a little more than twice as fast as the training time with a 4 CPU limit. However, when comparing the 16 CPU limit and 8 CPU limit training time, there is very little improvement. This can be attributed to the fact that there were other workloads running on the worker node where the pipeline pod was scheduled and as well as synchronization waits between the training processes/threads. In other words, to improve the training time for the 16 cpu limit test it would be necessary to schedule the pipeline pod on a worker node with more than 16 CPU and fewer competing workloads.
+
Sample sizes for PCC model training
+
+
+Important
+Do not train with more than 10K labeled samples. 10K samples is the recommended limit for PCC training.
+The training times for a single epoch and different sample sizes are shown below. In general, the larger the size of the labeled sample data set, the longer the training time will be. You can see below there is an +exception to this rule. When comparing the single epoch training time between the 1K sample size and the 5K sample size, you can see that the single epoch training time for 5K sample size is only 82 minutes compared to 220 minutes for the 1K sample size. This is due to the fact that there were 30 problem codes in this test and with 1K sample size there were an insufficient number of samples per problem code. As a result, the model leveraged Watson X to generate synthetic samples and this process accounts for the additional training time for the 1K sample set.
+
+
+Info
+The results below show training time for a single epoch. For a real training, 12 epochs is used and therefore the single epoch training times below should be multiplied by 12 to get the real training time. Note, there is a default timeout of 14400 minutes (or 10 days) for training to complete.
+
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/mif-jms/bestpractice/index.html b/mas/mif-jms/bestpractice/index.html
new file mode 100644
index 0000000..ef6997a
--- /dev/null
+++ b/mas/mif-jms/bestpractice/index.html
@@ -0,0 +1,390 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MAS Manage MIF/JMS
+Lab Result Highlights
+-
+
-
+
The lab results indicate a significant correlation between the transaction per second (TPS) and database disk IO utilization. This correlation suggests that the level of transactional activity directly impacts the IO workload on the database disk. Conversely, the IO workload acts as a limitation on the system's ability to handle a larger volume of transactions. +
+
+ -
+
When IO is not the limiting factor, increasing the number of MEA Pods can positively impact the processing performance.
+
+ -
+
Increasing the Message-Driven Bean (MDB) instances can potentially have a positive impact on system performance. It is recommended to adjust the number of records per message, the # of MDB and the batch size. By finding the right balance, you can target a resource usage of around 2 cores and 4-7GB of RAM that can help ensure efficient utilization without overburdening the MEA pods.
+
+ -
+
Based on the lab results, it has been observed that a large number of internal error messages have a substantial impact on processing throughput.
+
+ -
+
Under a certain circumstance, the configuration parameter mxe.int.splitdataonpost does not demonstrate a positive impact. To validate its effectiveness, it is recommended to perform a dry run in your specific environment for verification.
+
+
Performance Troubleshooting Checklist
+To troubleshoot and optimize performance, follow this checklist:
+-
+
- Ensure adherence to best practices for optimizing performance in your DB, Openshift, and MAS environments. +
- Monitor disk IO utilization of the database and maintain it within acceptable limits to avoid performance degradation due to saturated disk resources. +
- Adjust the number of records per message and the MDB/batch size to effectively manage resource utilization of MEA pods. Aim for a resource consumption range of approximately 2 cores and 4-7 GB. +
- Regularly check the message queue to prevent it from becoming empty, ensuring a steady flow of messages for processing. +
- Minimize the occurrence of integration error messages as they can significantly impact processing throughput. Pay attention to a high volume of internal error messages and investigate the message reprocessing application for further insights. +
- Set a sufficiently large value for
maxMessageDepthto avoid message queue overflow. It is recommended to match SIBus's default value of at least 500,000.
+ - When the need for additional MEA pods arises, consider scaling up the number of worker nodes to accommodate the increased demand effectively. +
Test Methodologies
+-
+
-
+
Establish a monitoring system to track essential performance metrics throughout the testing process.
+
+ -
+
Begin with a dry run using a single MEA pod to establish a baseline benchmark for performance evaluation.
+
+ -
+
Adjust the Message-Driven Bean (MDB) and BatchSize parameters to optimize resource utilization within an appropriate range for the MEA pod.
+
+ -
+
Scale up the number of MEA pods as needed to meet performance requirements and accommodate increased workload.
+
+ -
+
Continuously monitor and assess the performance of both the database and the application to identify any bottlenecks or areas for improvement.
+
+
By following these test methodologies, you can effectively monitor and optimize the performance of your system, ensuring efficient resource utilization and maintaining satisfactory levels of performance.
+Major Performance Related Factors for MIF
+| Component | +Configuration | +Adjustable or Scalable | +Observeration & Best Practice | +
|---|---|---|---|
| JMS / MIF | +maxMessageDepth | +Yes | +Make it large enough. If it is too small, when the queue is full, the process fails and may be hard to recover. Recommend 500,000 same as SIBus | +
| + | maxEndpoints | +Yes | +Limit the maxConcurrency | +
| + | MDB(maxConcurrency) | +Yes | +Alone with BatchSize will impact processing speed and MEA pods resouce utliitzation | +
| + | BatchSize(maxBatchSize) | +Yes | +Alone with MDB will impact processing speed and MEA pods resouce utliitzation | +
| Maximo | +# of JMS Pod | +Yes | +1 JMS Server works well in benchmark test. It does not consume a significant resource | +
| + | # of MEA Pod | +Yes | +Able to linear scale | +
| + | MEA CPU / MEM Usage | +Yes | +Adjust JMS/MDB and BatchSize to control MEA pods resources in a reasonable range e.g. (2 - 3 core / 4 -7G) | +
| + | JMS CPU / MEM Usage | +Yes | +Default setting works well in the benchmark test | +
| + | DB CPU / MEM Usage | +Yes | +Ensure DB has sufficient resource | +
| + | DB Disk IO Util % | +Yes, but sometime it is hard to adjust | +Disk IO throughput is critial for the overall processing | +
| + | DB Lock Holds | +N/A | ++ |
| + | DB Tuning: Long Running Query, # of Appl, Memory.. | +Yes | +Follow the best practice to tune DB | +
| + | Maximo Sequence Cache | +Yes | +a reasonable # e.g. 20 or 50 can reduce the db cpu and processing time | +
| + | mxe.int.splitdataonpost | +Yes | ++ |
| Message | +# of record per Message | +Yes | ++ |
| + | data structure (complexity of the record) | +N/A | +Impacts performance because of business logic check | +
| + | Record Quality (record cannot be processed) | +Yes | +A large amount of int error messages slow down the overall processing speed | +
| Misc | +Method & Speed to post message into queue | +Yes | +Ensure message post (writing to queue) as fast as possible. A slow pacing lowes the env processing capacity. | +
| + | Any other concurrent transactions | +N/A | +other concurrency workloads impact the processing time | +
| + | Worker Node Capacity | +Yes | +Worker Node Capacity may limit working pod (e.g. MEA) capacity. Pod distribution should also be considered. | +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/mif-jms/tps.png b/mas/mif-jms/tps.png
new file mode 100644
index 0000000..18508a9
Binary files /dev/null and b/mas/mif-jms/tps.png differ
diff --git a/mas/mif-kafka/bestpractice/index.html b/mas/mif-kafka/bestpractice/index.html
new file mode 100644
index 0000000..77f8bf3
--- /dev/null
+++ b/mas/mif-kafka/bestpractice/index.html
@@ -0,0 +1,226 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MAS Manage MIF/Kafka
+Lab Result Highlights
+-
+
-
+
Same to MIF/JMS test, the lab results indicate a significant correlation between the transaction persecond (TPS) and database disk IO utilization. This correlation suggests that the level of transactionalactivity directly impacts the IO workload on the database disk. Conversely, the IO workload acts as alimitation on the system's ability to handle a larger volume of transactions.
+
+ -
+
The results also demonstrate a notable connection between the disk IO throughput and the TPS (Transactions Per Second).
+
+ -
+
Doubling the number of CRON JVMs and Kafka topic partitions leads to a twofold increase in the maximum TPS. However, this change also results in an enlarged distribution difference, growing from 2% to 10%. Consequently, in the final phase, the overall processing rate diminishes, with the TPS decreasing from 72 to 66, attributed to the Kafka rule - which allows a maximum of 1 consumer per partition.
+
+ -
+
Increasing the number of partitions may result in better performance for small messages (e.g., 10 assetsper message) compared to large messages. Please ensure that there are an adequate number ofmessages in the queue for processing.
+
+ -
+
When evaluating the performance of a single MEA JVM, the TPS in MIF/Kafka matches that of JMS. Nevertheless, when multiple processing JVMs are utilized, JMS surpasses performance due to its more equitable workload distribution. From a best-practice standpoint, it is advisable to have one Kafka topic with 6 partitions and multiple Kafka topics for parallel processing.
+
+
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/mobile/bestpractice/index.html b/mas/mobile/bestpractice/index.html
new file mode 100644
index 0000000..7b256bc
--- /dev/null
+++ b/mas/mobile/bestpractice/index.html
@@ -0,0 +1,234 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MAS Manage Mobile
+Tips and Tricks:
+-
+
-
+
Strongly recommend creating a mobile database for supporting data downloads. Online support downloading can significantly impact the performance of Mobile Pods, databases, and networks.
+
+ -
+
To mitigate download failures, consider increasing the timeout value for the ingressor. The default server/client timeout is set too low, affecting the pass rate. Use the following commands to raise the default value:
+
+oc -n openshift-ingress-operator patch ingresscontroller/default --type=merge -p '{"spec":{"tuningOptions": {"clientTimeout": "300s"}}}'
+oc -n openshift-ingress-operator patch ingresscontroller/default --type=merge -p '{"spec":{"tuningOptions": {"serverTimeout": "300s"}}}'
+ -
+
Scaling up the coreapi pod can enhance the downloading experience for the mobile app.
+
+ -
+
Consider scaling up the mobile pods when the CPU usage of a pod exceeds 4.
+
+ -
+
Optimal disk throughput for the database is crucial for a smooth app downloading experience.
+
+ -
+
Observations from lab tests suggest that balanced node resource utilization is crucial for optimal performance. It is worth noting that the default topology spread constraints in the ManageWorkspace Custom Resource (CR) are set to "topologyKey: topology.kubernetes.io/zone". However, in a single-zone cluster, if the pod is not being evenly distributed across worker nodes, considerto be set to "topologyKey: topology.kubernetes.io/hostname" instead.
+
+
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/mongodb/bestpractice/index.html b/mas/mongodb/bestpractice/index.html
new file mode 100644
index 0000000..7103ead
--- /dev/null
+++ b/mas/mongodb/bestpractice/index.html
@@ -0,0 +1,222 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ MongoDB
+MongoDB Troubleshoot:
+-
+
- mongostat:
mongostat --username admin --password <password> --authenticationDatabase admin --ssl --sslAllowInvalidCertificates 2
+ - mongotop:
mongotop --username admin --password <password> --authenticationDatabase admin --ssl --sslAllowInvalidCertificates 2
+ - check mongod log for slow queries (MongoDB community):
oc logs -n <mongo namespace> <mongo pod name> -c mongod | grep -iE 'Slow query'
+ - long connection over 3 seconds:
db.currentOp({"active" : true,"secs_running" : { "$gt" : 3 },"ns" : /^msg/})
+ - kill long running connection:
db.killOp("opid")
+ - locking:
db.serverStatus().globalLock
+ - mem:
db.serverStatus().mem
+ - wiredTiger cache:
db.serverStatus().wiredTiger.cache
+ - concurrent:
db.serverStatus().connections
+
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/monitoring/guidance/index.html b/mas/monitoring/guidance/index.html
new file mode 100644
index 0000000..c4a83e7
--- /dev/null
+++ b/mas/monitoring/guidance/index.html
@@ -0,0 +1,257 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Monitoring
+Monitoring your OpenShift clusters is critical for the environment health, the quality of services. It helps ensure that all deployed workloads are running smoothly and that the environment is properly scoped.
+OpenShift Monitoring Service (Promethus/Grafana)
+OpenShift Container Platform includes a pre-installed monitoring stack that is based on the Prometheus/Grafana. MAS also provides app-level promethus metrics and a set of Grafana dashboards for application health. More installation, configuration details can be found in IBM MAS Monitoring
+
+
+Best practice for OpenShift Monitoring Service
+-
+
- enable User Workload:
enableUserWorkload: false
+ - consider to increase the promethus retention policy whose default value is 24h and add persistent volumes +
- consider to change Alert Manager's storage class and size +
Below is the sample for configmap cluster-monitoring-config
+apiVersion: v1
+kind: ConfigMap
+metadata:
+ name: cluster-monitoring-config
+ namespace: openshift-monitoring
+data:
+ config.yaml: |
+ enableUserWorkload: true
+ prometheusK8s:
+ retention: 90d
+ volumeClaimTemplate:
+ spec:
+ storageClassName: nfs-client
+ resources:
+ requests:
+ cpu: 200m
+ storage: 300Gi
+ memory: 2Gi
+ limits:
+ cpu: 2
+ memory: 4Gi
+ alertmanagerMain:
+ volumeClaimTemplate:
+ spec:
+ storageClassName: nfs-client
+ resources:
+ requests:
+ storage: 20Gi
+
+
+
+ Note
+-
+
- Except OpenShift Monitoring Service (Promethus/Grafana), there are other paid solutions like IBM Instana, New Relic, Data Dog that also support OCP. +
- If the cluster is cloud based, consider to use cloud provider's monitoring tool for additional info like network, disk, managed services. e.g. AWS CloudWatch, IBM Log Analysis... +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/ocp/bestpractice/index.html b/mas/ocp/bestpractice/index.html
new file mode 100644
index 0000000..1cf4e72
--- /dev/null
+++ b/mas/ocp/bestpractice/index.html
@@ -0,0 +1,291 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ OpenShift Container Platform
+Cluster Insights Advisor
+Highly recommend to use OpenShift cluster Insights Advisor that to check for any issue related to the current version, nodes and mis-configurations. It is the first step for the problem diagnosis.
+Steps:
+-
+
- Login on OpenShift Console +
- Go to Administration -> Cluster Settings +
- Click OpenShift Cluster Manager in Subscription section. It redirects the url to RedHat Hybrid Cloud Console +
- Click Insights Advisor +
PID limit for docker
+This settings control how many processes can be run within one single container. If it is too small, it can cause folk bomb issue. E.g. db2w instance may be unavailable when there are thousands of connections/agents upcoming or Openshift Container Storage not behaving well with a large amount of PVCs.
+OOB value for OCP platforms:
+| Platform Version | +Default Value | +
|---|---|
| IBM ROKS (4.8) | +231239 | +
| AWS ROSA | +4096 in OpenShift 4.11 and higher | +
| Azure Self-Managed OCP | +1024 | +
Steps to check or update PID limit: +
$ oc debug node/$NODE_NAME
+$ chroot /host
+$ cat /etc/crio/crio.conf
+# add / modify the line "pids_limit = <new value>"
+# run belows commands to reboot services and worker nodes
+$ systemctl daemon-reload
+$ systemctl restart crio
+$ shutdown -r now
+HAProxy Router
+Ingress Controller
+Openshift HAProxy supports up to 20k connections per pod. Consider to scale up ingress pod for any app (like IoT) with a high volume connection workload.
+Scale up ingress controller
+-
+
- command:
oc patch -n openshift-ingress-operator ingresscontroller/default --patch '{"spec":{"replicas": 3}}' --type=merge
+
Max Connection
+One of the most important tunable parameters for HAProxy scalability is the maxconn parameter. The router can handle a maximum number of 20k concurrent connections by using oc adm router --max-connections=xxxxx. This parameter will be impacted by node settings sysctl fs.nr_open and sysctl fs.file-max. HAproxy will not start if maxconn is high, but node setting is low.
Note: OpenShift Container Platform no longer supports modifying Ingress Controller deployments by setting environment variables such as ROUTER_THREADS, ROUTER_DEFAULT_TUNNEL_TIMEOUT, ROUTER_DEFAULT_CLIENT_TIMEOUT, ROUTER_DEFAULT_SERVER_TIMEOUT, and RELOAD_INTERVAL. You can modify the Ingress Controller deployment, but if the Ingress Operator is enabled, the configuration is overwritten.
+Load Balance Algorithm
+Starting from OCP 4.10, there have been four load-balancing algorithms available: source, roundrobin, random, and leastconn. The default algorithm is set to random. In earlier versions of OCP, before 4.10, there were three load-balancing algorithms: source, roundrobin, and leastconn. The default algorithm in those versions was leastconn. Set up annotations for each route to change the default algorithm if needed. e.g. haproxy.router.openshift.io/balance=roundrobin
Master and Worker Nodes Consideration
+There are a wide selection instance types that comprise varying combinations of CPU, memory, disk and network. Below are a few considerations:
+-
+
- Each worker node will reserve about 1 core for internal services. In order to avoid the side effect of overcommit, 16core/64G is a good starting type for a normal worker node. A 8-core instance may not have insufficent capacity while 32-core instance may lose a big cluster capacity due to an outage or failure. +
- Using balanced CPU-memory worder nodes typically fits our work load -the ratio of CPU to memory is 1 to 4. +
- An instance with a higher memory/cpu ratio e.g. 8:1 is recommended for database nodes. +
- The number of worker nodes >=3. This will give a high availability needing a smaller built in redundant capacity. +
- For the product env, a 8core/32G is recommended for master nodes to avoid any bottleneck for the internal services. +
- An instance with 10GB ethernet is strongly recommended for the production env. +
- Check the GPU chip type for gpu node selection. +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/mas/sizing/guidance/index.html b/mas/sizing/guidance/index.html
new file mode 100644
index 0000000..38ede1a
--- /dev/null
+++ b/mas/sizing/guidance/index.html
@@ -0,0 +1,365 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sizing Guidance
+
+
+The sizing number in this page is based on a standard workload. Used as reference only.
+Sizing Calculation Sheet
+Use Sizing Calculation Sheet for MAS sizing.
+Factors that impact the sizing consideration
+-
+
- storage operator: e.g. ocs, odf... +
- cp4d services: e.g. db2w, watson studio... +
- mongodb service +
- kafka service +
OCS (OpenShift Container Storage)
+If using OCS to manage the storage class, OCS service itself requires minimum 3 nodes with 14 core / 32G (Note: this is the total request amount, not per node).
+ODF (OpenShift Data Foundation)
+3 OCP nodes will run ODF services. (NOTE: OCP clusters often contain additional OCP worker nodes which do not run ODF services.) +Each OCP node running ODF services has:16 core / 64 GB memory
+CP4D/DB2W Minimum Resource Requirement
+-
+
- When running CP4D/DB2W on OpenShift's worknode, each instance requires at least 6.1 core and 18G ram. Note: an instance pod cannot be scheduled if the node's (total capacity - total limit) is less than 6.1 core or 18G ram, +
- a dedicated worker node or external db is recommended. +
- db2 operator is an alternative. +
MAS Manage
+Based on the benchmark results, for sizing we recommend 50 - 75 user load per MAS Manage UI server bundle pod, which is equivalent to a JVM with 2 core on Maximo 7.6.x.
+MAS Resource Statistics
+-
+
- use below values as reference only. +
- the footprint is based on the loads and spec settings. e.g. IoT T-shirt size, Manage bundle and replic # +
- the value below is based on IoT small T-shirt size and Manage with only all-in-one bundle and replic =1 +
| App | +CPU Request (core) | +CPU Limits (core) | +Memory Rquest (GB) | +Memory Limits(GB) | +
|---|---|---|---|---|
| Add | +6 | +12 | +13 | +26 | +
| Assist | +12.4 | +57.7 | +19.46 | +62.38 | +
| Core | +1.5 | +18.95 | +6.27 | +32.5 | +
| Health | +2.9 | +15.6 | +7.12 | +30.84 | +
| HPU | +0.9 | +5.5 | +0.92 | +6.5 | +
| IoT | +19.66 | +214.65 | +57.08 | +269 | +
| Manage | +2.9 | +11.1 | +4.04 | +17 | +
| Monitor | +5.4 | +32.4 | +12.84 | +55.5 | +
| Optimizer | +7.4 | +19.3 | +25.57 | +117 | +
| Predict | +3.1 | +12.5 | +6.13 | +24.5 | +
| Additional cost | +- - - - - - - | +- - - - - - - | +- - - - - - - - - - - | +- - - - - - - - - - - | +
| ocs* | +14 | +32 | +14 | +32 | +
| cp4d (with 2 db2w instances)* | +31.59 | +40.7 | +235.39 | +249.70 | +
| each additional manage pod* | +1 | +6 | +2 | +10 | +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/maximo-7/bestpractice/index.html b/maximo-7/bestpractice/index.html
new file mode 100644
index 0000000..510ffd7
--- /dev/null
+++ b/maximo-7/bestpractice/index.html
@@ -0,0 +1,223 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Info
+-
+
- The next version of Maximo 7 is MAS Manage 8.x. This page includes the best practice documents for Maximo EAM v7 only. +
- The DB section in each best practice is still applicable to MAS Manage. +
Best Practices for Maximo 7.x
+-
+
- Maximo Best Practices for System Performance 7.6.x (Version 1.3) +
- Maximo Anywhere 7.6.2 Best Practices (2018 Edition) +
- Maximo Performance Tuning Tips: Additional tips on top of Best Practices for System Performance +
- Maximo Best Practices for System Performance 7.5.x (Version 2.1) +
- Improving Start Center performance in Maximo +
- System Properties to Monitor and Troubleshoot Performance +
- Maximo Report Performance Guide 7.6.x (Version 1) +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/maximo-7/download/2018-GOMaximo-Maximo-Anywhere-Best-Practices.pdf b/maximo-7/download/2018-GOMaximo-Maximo-Anywhere-Best-Practices.pdf
new file mode 100644
index 0000000..36ceb6d
Binary files /dev/null and b/maximo-7/download/2018-GOMaximo-Maximo-Anywhere-Best-Practices.pdf differ
diff --git a/maximo-7/download/Maximo Best Practices for System Performance 7.5.x.pdf b/maximo-7/download/Maximo Best Practices for System Performance 7.5.x.pdf
new file mode 100644
index 0000000..dceaccc
Binary files /dev/null and b/maximo-7/download/Maximo Best Practices for System Performance 7.5.x.pdf differ
diff --git a/maximo-7/download/Maximo Best Practices for System Performance 7.6.x v1.3.pdf b/maximo-7/download/Maximo Best Practices for System Performance 7.6.x v1.3.pdf
new file mode 100644
index 0000000..4245f22
Binary files /dev/null and b/maximo-7/download/Maximo Best Practices for System Performance 7.6.x v1.3.pdf differ
diff --git a/maximo-7/download/Maximo Performance Tunring & Best Practices Tips.pdf b/maximo-7/download/Maximo Performance Tunring & Best Practices Tips.pdf
new file mode 100644
index 0000000..b3e52b7
Binary files /dev/null and b/maximo-7/download/Maximo Performance Tunring & Best Practices Tips.pdf differ
diff --git a/maximo-7/download/Maximo_Version76_ReportPerformance_Guide_Rev1.pdf b/maximo-7/download/Maximo_Version76_ReportPerformance_Guide_Rev1.pdf
new file mode 100644
index 0000000..10fce55
Binary files /dev/null and b/maximo-7/download/Maximo_Version76_ReportPerformance_Guide_Rev1.pdf differ
diff --git a/pd/checklist/index.html b/pd/checklist/index.html
new file mode 100644
index 0000000..77688d4
--- /dev/null
+++ b/pd/checklist/index.html
@@ -0,0 +1,354 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Performance Diagnosis
+
+
+Info
+A monitoring system is strongly recommended to track the environment health and the quality of services.
+Diagnostic Utility
+| Scope | +Name | +Used for | +
|---|---|---|
| OCP | +OpenShift Monitoring Service | +OpenShift Cluster and MAS | +
| DB2 | +IBM DSM | +DB2 Historical and Realtime Troubleshooting | +
| DB2 | +db2top | +DB2 Realtime Troubleshooting | +
| DBTest | +DBTest | +An utility to test db network latency and fetching time | +
| Oracle | +AWR, StatsPack | +Historical Troubleshooting | +
| JVM | +IBM Support Assistant | +Heap Dump and GC Log Analysis | +
| JVM | +MAT | +JVM Dump Analysis | +
| Maximo | +PerfMon | +- Maximo UI Activity Tracing - Note: Enabling PerfMon may significantly degrade server performance. - Recommend for a single user with Dev/Test env only |
+
| MongoDB | +mongotop | +MongoDB Realtime Troubleshooting | +
| HAR | +HTTP Archive Viewer | +HAR Analysis - for web page and client side (browser) performance | +
| SQL | +Poor SQL | +Online SQL Formatter | +
| SQL | +Squirrl | +Universal SQL Client | +
| SSL | +SSL Shopper | +Online certificate decode tool | +
| OS | +top | +Process and thread level analysis, hotspot analysis - top is available in most containers and on OCP worker nodes | +
| OS | +sar | +a system command be used to monitor system resources like cpu, memory, disk, network... | +
| OCP | +oc debug node/<node name> |
+Worker node debugging | +
Factors in system performance
+System performance depends on more than the applications and the database. The network architecture affects performance. Application server configuration can hurt or improve performance. The way that you deploy Maximo across servers affects the way the products perform. Many other factors come into play in providing the end-user experience of system performance. +Subsequent sections in this paper address the following topics:
+-
+
- System architecture setup including OCP, Instance Type, Storage +
- App and DB server configuration +
- Network issues +
- Bandwidth +
- Load balancing +
- Database tuning +
- SQL tuning +
- Scheduled tasks (cron tasks) +
- Reporting +
- Integration with other systems using the integration framework +
- Troubleshooting +
Performance Check List
+-
+
- check node status. e.g. any NOT Ready worker nodes +
- if there is any pod or node cpu, memeory usage approaching to the limit? +
- if there is any pod restarted many time recently? +
- if there is any JVM Heapdump dump? +
- if there is any JVM Hung Thread +
- if there is any node or pod with a high system or IO wait (20%)? +
- if there is any node memory, disk or pid pressure? +
- if the response time is high (over 2 sec)? +
- if any long running (over 2 sec) or high cpu cost query? +
- if there is network bottleneck (e.g. load-balancer) +
- is app server or db server busy?
-
+
- if app server is busy
-
+
- check the request, limit value for cpu, memory +
- should replic memebers be increased? +
+ - if db server is busy
-
+
- check cpu, memory, disk current usage and limit value +
- check any utility in the background. e.g. backup +
- check db lock +
- check if there is any high cost query +
- check disk performance +
+
+ - if app server is busy
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pd/db2-performance-diagnosis/index.html b/pd/db2-performance-diagnosis/index.html
new file mode 100644
index 0000000..4675e83
--- /dev/null
+++ b/pd/db2-performance-diagnosis/index.html
@@ -0,0 +1,320 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ DB2TOP
+db2top can be used for a real-time diagnosis.
+-
+
- Command:
db2top -db <dbname>-
+
- press h: help screen +
- press I: reset the interval time (default is 2 seconds) +
- press m: memory screen +
- press B: bottleneck screen +
- press b: bufferpool screen +
- press T: Table screen +
- press U: locks screen +
- press u: utility screen to check if runstat is running +
- press D: Dynamic SQL screen +
- Catch High CPU SQL in Dynamic SQL screen, do:
-
+
- Press z and 5 to sort by cpu usage +
- Copy SQL Hashcode +
- Press L and Paste SQL Hashcode +
+
+ - Notes: Be cautions when taking any snapshot. +
- See more details on User Manual +
Diagnosis Commands
+-
+
-
+
list memory allocation:
++db2mtrk -i -d –v +
+ -
+
list long run query:
++SELECT ELAPSED_TIME_MIN,SUBSTR(AUTHID,1,10) AS AUTH_ID, AGENT_ID,APPL_STATUS,SUBSTR(STMT_TEXT,1,20) AS SQL_TEXT FROM SYSIBMADM.LONG_RUNNING_SQL WHERE ELAPSED_TIME_MIN > 0 ORDER BY ELAPSED_TIME_MIN DESC; +
+ -
+
list backup/restore status:
++db2pd -barstats -d <dbname> +
+ -
+
list most active tables:
++SELECT SUBSTR(TABSCHEMA,1,10) AS SCHEMA,SUBSTR(TABNAME,1,20) AS NAME,TABLE_SCANS,ROWS_READ,ROWS_INSERTED,ROWS_DELETED FROM TABLE(MON_GET_TABLE('','',-1)) ORDER BY ROWS_READ DESC FETCH FIRST 5 ROWS ONLY +
+ -
+
list most active indexes:
++SELECT SUBSTR(TABSCHEMA,1,10) AS SCHEMA,SUBSTR(TABNAME,1,20) AS NAME,IID,NLEAF, NLEVELS,INDEX_SCANS,KEY_UPDATES,BOUNDARY_LEAF_NODE_SPLITS + NONBOUNDARY_LEAF_NODE_SPLITS AS PAGE_SPLITS FROM TABLE(MON_GET_INDEX('','',-1)) ORDER BY INDEX_SCANS DESC FETCH FIRST 5 ROWS ONLY +
+ -
+
list db2 advise for the statement:
++db2advis -database bludb -s "select * from maximo.ahfactorhistory where ahdriverhistoryid = 123 for read only" -n MAXIMO -q MAXIMO +
+ -
+
checking for indexes the need to be rebuilt
++db2 reorgchk current statistics on schema 'MAXIMO' > /tmp/reorgchk.log +Any indexes or tables with an
+*in the REORG column, indicate that they are candidates for reorg.
+ -
+
list the query execution plan:
++db2expln -database bludb -schema MAXIMO -package % -statement "select * from maximo.ahfactorhistory where ahdriverhistoryid = 123 for read only" -terminal -graph > query1_access_plan.txt +
+ -
+
list all indexes for a specific table:
++select * from syscat.indexes i where TABNAME ='ITEMSTRUCT' +
+ -
+
list insert/update/delete/tablescan stats for a specific table:
++SELECT rows_read,rows_inserted,rows_updated,rows_deleted,table_scans FROM TABLE(MON_GET_TABLE('MAXIMO','ASSET',-2)) +
+ -
+
list insert/update/delete/tablescan stats for all tables:
++SELECT SUBSTR(TABSCHEMA,1,10) AS SCHEMA,SUBSTR(TABNAME,1,20) AS NAME,TABLE_SCANS,ROWS_READ,ROWS_INSERTED,ROWS_DELETED FROM TABLE(MON_GET_TABLE('','',-1)) ORDER BY ROWS_READ DESC FETCH FIRST 5 ROWS ONLY" +
+ -
+
list top 10 big tables:
++select creator, name, avgrowsize, card, stats_time, avgrowsize*card as tbsize, npages*t.pagesize/1024/1024 as tbsize_inMB from sysibm.systables t1, syscat.tablespaces t where creator not like 'DB2%' and t1.tbspace=t.tbspace order by tbsize desc fetch first 10 rows only +
+ -
+
list data and index size for one table:
++select tabschema, tabname, DATA_OBJECT_P_SIZE/1024 as data_inMB, INDEX_OBJECT_P_SIZE/1024 as index_inMB,LONG_OBJECT_P_SIZE/1024 LongObj_inMB, LOB_OBJECT_P_SIZE/1024 as LOB_inMB from table(sysproc.admin_get_tab_info('MAXIMO','WORKORDER')) +
+ -
+
list error message:
++db2 ? <sqlerror> +
+ -
+
+db2pd: monitor and troubleshoot DB2 database command
+ db2diag: db2diag logs analysis tool command
+db2set: db2 global settings
+db2 get dbm cfg: db2 database manager configuration
+db2 get db cfg: db2 database configuration
+
IBM Data Server Manager (IBM DSM)
+IBM DSM is useful to do both real-time/ historical data diagnosis, find out the expensive sql query, justify cpu spent on sql execution or other e.g. sorting, parsing, fetching, io and so on. It requires pre-configuration.
+A high-level set up:
+-
+
- Download the latest version of Data Server Manager from IBM developerWorks or IBM Passport Advantage Online, then extract to /opt/ibm/dsm +
- run setup.sh to set up and create admin user +
- run start.sh to start the server, url is http://hostname:11080/console +
- log on the console, select a time period (e.g. peak time) and then generate report. +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pd/dbtest/index.html b/pd/dbtest/index.html
new file mode 100644
index 0000000..ab1fb2c
--- /dev/null
+++ b/pd/dbtest/index.html
@@ -0,0 +1,268 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ DBTest Utility
+notes: This utility requires Java version 11 or higher.
+The DBTest Utility has two modes:
+Benchmark Mode (the default): is to measure database connection time, query execution time and data fetching time for every 100 records.
+Query Mode: is to display the query result with database connection time, query execution time and data fetching time.
+Here is an example demonstrating how to utilize this utility in the Maximo UI pod.
+Run DBTest in MAS Manage maxinst pod
+-
+
- go to maxinst pod in the MAS Manage namespace -> terminal tab, then execute below commands: +
cd /tmp
+curl -L -v -o run-dbtest-in-maxinst-pod.sh https://ibm-mas.github.io/mas-performance/pd/download/DBTest/run-dbtest-in-maxinst-pod.sh
+bash run-dbtest-in-maxinst-pod.sh
+Run DBTest in Maximo UI Pod
+-
+
- go to maximo ui pod -> terminal tab, then execute below commands: +
# change to /tmp
+cd /tmp
+
+# download DBTest
+curl -L -v -o DBTest.class https://ibm-mas.github.io/mas-performance/pd/download/DBTest/DBTest.class
+
+# set DBURL. If this utility is in maximo UI pod, set DBURL="$MXE_DB_URL"
+export DBURL="<jdbc url>" or export DBURL="$MXE_DB_URL" or export DBURL="${MXE_DB_URL}sslTrustStoreLocation=${java_truststore};sslTrustStorePassword=${java_truststore_password};"
+export DBUSERNAME='<username>'
+export DBPASSWORD='<password>'
+export SQLQUERY='select * from maximo.maxattribute'
+
+# execute the utility in benchmark mode
+java -classpath .:$(dirname "$(find /opt | grep "oraclethin.jar" | head -n 1)")/* DBTest
+Result Samples:
+Given optimal network latency and a healthy database status, the expected data fetching time is less than 10 milliseconds.
+Good Result:
+
Bad Result:
+
Execute the utility in query mode
+java -classpath .:$(dirname "$(find /opt | grep "oraclethin.jar" | head -n 1)")/* DBTest -q
+Output Sample:
+(base) [~/javatool]$ java -classpath .:./lib/* DBTest -q
+Dec. 06, 2023 11:49:47 A.M. DBTest getConnection
+INFO: Loading Class took: 0.029 seconds
+Dec. 06, 2023 11:49:53 A.M. DBTest getConnection
+INFO: DB Connecting took: 6.55 seconds
+Dec. 06, 2023 11:49:53 A.M. DBTest printResult
+INFO: Query Execution took: 0.099 seconds
+APP, OPTIONNAME, DESCRIPTION, ESIGENABLED, VISIBLE, ALSOGRANTS, ALSOREVOKES, PREREQUISITE, SIGOPTIONID, LANGCODE, HASLD, ROWSTAMP
+---------------------------------------------------------------------------------------------------------------------------------
+APIKEY, READ, Access to API Keys application, 0, 1, null, ALL, null, 200004204, EN, 0, 290874862
+Dec. 06, 2023 11:49:54 A.M. DBTest printResult
+INFO: Fetching Record took: 0.058 seconds
+
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pd/download/DBTest/DBTest.class b/pd/download/DBTest/DBTest.class
new file mode 100644
index 0000000..d2023c2
Binary files /dev/null and b/pd/download/DBTest/DBTest.class differ
diff --git a/pd/download/DBTest/run-dbtest-in-maxinst-pod.sh b/pd/download/DBTest/run-dbtest-in-maxinst-pod.sh
new file mode 100644
index 0000000..af848c6
--- /dev/null
+++ b/pd/download/DBTest/run-dbtest-in-maxinst-pod.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+# curl -L -v -o run-dbtest-in-maxinst-pod.sh https://ibm-mas.github.io/mas-performance/pd/download/DBTest/run-dbtest-in-maxinst-pod.sh
+
+cd /tmp
+
+curl -L -v -o DBTest.class https://ibm-mas.github.io/mas-performance/pd/download/DBTest/DBTest.class
+
+
+IFS='=' read -r key value <<< $(cat /etc/database/operator/secret/maximo.properties |grep mxe.db.url=)
+if [[ "${value}" == *"sslConnection=true"* ]]; then
+ export DBURL="${value}sslTrustStoreLocation=${java_truststore};sslTrustStorePassword=${java_truststore_password};"
+else
+ export DBURL="${value}"
+fi
+
+IFS='=' read -r key value <<< $(cat /etc/database/operator/secret/maximo.properties |grep mxe.db.user=)
+export DBUSERNAME="${value}"
+
+IFS='=' read -r key value <<< $(cat /etc/database/operator/secret/maximo.properties |grep mxe.db.password=)
+export DBPASSWORD="${value}"
+
+IFS='=' read -r key value <<< $(cat /etc/database/operator/secret/maximo.properties |grep mxe.db.schemaowner=)
+export DBSCHEMAOWNER="${value}"
+if [ -z "$DBSCHEMAOWNER" ]; then
+ export SQLQUERY="select * from maxattribute"
+else
+ export SQLQUERY="select * from ${DBSCHEMAOWNER}.maxattribute"
+fi
+
+java -classpath .:/opt/IBM/SMP/maximo/tools/maximo/lib/* "${JAVA_TOOL_OPTIONS}" DBTest
\ No newline at end of file
diff --git a/pd/download/Performance Test Best Practices for Rational Performance Tester.pdf b/pd/download/Performance Test Best Practices for Rational Performance Tester.pdf
new file mode 100644
index 0000000..dc7067d
Binary files /dev/null and b/pd/download/Performance Test Best Practices for Rational Performance Tester.pdf differ
diff --git a/pd/download/PerformanceTestBestPracticesforLoadRunner.pdf b/pd/download/PerformanceTestBestPracticesforLoadRunner.pdf
new file mode 100644
index 0000000..43909af
Binary files /dev/null and b/pd/download/PerformanceTestBestPracticesforLoadRunner.pdf differ
diff --git a/pd/download/o2j/o2j-amd64 b/pd/download/o2j/o2j-amd64
new file mode 100644
index 0000000..73d24a2
Binary files /dev/null and b/pd/download/o2j/o2j-amd64 differ
diff --git a/pd/download/o2j/o2j-arm64 b/pd/download/o2j/o2j-arm64
new file mode 100644
index 0000000..475704f
Binary files /dev/null and b/pd/download/o2j/o2j-arm64 differ
diff --git a/pd/images/dbtest-badresult.png b/pd/images/dbtest-badresult.png
new file mode 100644
index 0000000..8f3ef43
Binary files /dev/null and b/pd/images/dbtest-badresult.png differ
diff --git a/pd/images/dbtest-goodresult.png b/pd/images/dbtest-goodresult.png
new file mode 100644
index 0000000..7352507
Binary files /dev/null and b/pd/images/dbtest-goodresult.png differ
diff --git a/pd/jvm-performance-insight/index.html b/pd/jvm-performance-insight/index.html
new file mode 100644
index 0000000..a845a73
--- /dev/null
+++ b/pd/jvm-performance-insight/index.html
@@ -0,0 +1,262 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ As a result of architectural modifications, Maximo 8.x (MAS Manage app) now operates on WebSphere Liberty Base 21.0.0.5 with OpenJ9 within the OpenShift Container Platform (OCP). It's essential to note that JVM arguments outlined in the 7.x Best Practice documentation may not be relevant or applicable to the Maximo 8.x environment. Here are additional details:
+WebSphere Liberty
+As of WebSphere Liberty 18.0.0.1, the thread growth algorithm is enhanced to grow thread capacity more aggressively so as to react more rapidly to peak loads. For many environments, this autonomic tuning provided by the Open Liberty thread pool works well with no configuration or tuning by the operator. If necessary, you can adjust coreThreads and maxThreads value.
Generic JVM Arguments
+-
+
-
+
-Xgcpolicy:gencon
+Gencon is the default policy in OpenJ9, this parameter works in both 7.x and 8.x
+
+ -
+
-Xmx or -XX:MaxRAMPercentage (maximum heap size)
+If not specifying -Xmx value, JVM uses 75% of total container memory when -XX:+UseContainerSupport is set. When -Xmx is set, -XX:MaxRAMPercentage will be ignored.
+
+ -
+
-XX:+UseContainerSupport/-XX:-UseContainerSupport
+If -XX:+UseContainerSupport is set, it allows to change the InitialRAMPercentage and MaxRAMPercentage values. -Xms and -Xmx can overwrite the limits.
+
+ -
+
-Xmn (Nursery Space)
+Setting the size of the nursery when using this policy can be very important to optimize performance. 25 - 33% of total heap is recommended. Please note manage pod limited memory is 10G that is not Total heap size. Heap size is based on (-Xmx or -XX:MaxRAMPercentage) setting. 10G also includes memory used by websphere for cache, compilation as well maximo mmi container.
+
+ -
+
-Xgcthreads4
+This parameter is used to set the number of threads that the Garbage Collector uses for parallel operations. By default, it is set to n -1 in OpenJ9 where n is the number of reported cpu on the node. You might want to restrict the number of GC threads used by each VM to reduce some overhead.
+
+ -
+
-XcompilationThreads4
+This parameter is used to specify the number of compilation threads that are used by the JIT compiler. Same as gcthread, you might want to restrict the number of compilation threads used by each VM to reduce some overhead.
+
+ -
+
-Xshareclasses
+this parameter is used to share class data between running VMs, which can reduce the startup time for a VM once the cache has been created.
+
+ -
+
‑Xdisableexplicitgc (Recommended)
+This parameter is used to disabling explicit garbage collection disables any System.gc() calls from triggering garbage collections. For optimal performance, disable explicit garbage collection.
+
+ -
+
-Djava.net.preferIPv4Stack=true/-Djava.net.preferIPv6Addresses=false
+For performance reasons, Maximo recommends to set this property to true. Note: this parameter can not be applied on the hosts that only communicate with ipv6.
+
+ -
+
-XX:PermSize and -XX:MaxPermSize + Maximo 7.x BP recommends 320m. If seeing an OOM for PermSize, consider to increase to 512MI or higher.
+
+ -
+
-Xcodecache32m + The maximum value you can specify for -Xcodecache is 32 MB. JIT compiler might allocate more than one code cache. It is controlled by -Xcodecachetotal which default value is 256MB.
+
+ -
+
-Xverbosegclog
+Enable verbose gc log for the garbage collection analysis
+
+ -
+
-Xtune:virtualized (under review)
+Optimizes OpenJ9 VM function for virtualized environments, such as a cloud, by reducing OpenJ9 VM CPU consumption when idle.
+
+
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pd/mcpi/image-1.png b/pd/mcpi/image-1.png
new file mode 100644
index 0000000..6bea1a1
Binary files /dev/null and b/pd/mcpi/image-1.png differ
diff --git a/pd/mcpi/image.png b/pd/mcpi/image.png
new file mode 100644
index 0000000..285963d
Binary files /dev/null and b/pd/mcpi/image.png differ
diff --git a/pd/mcpi/maximo-cpi-deployment-sa.yaml b/pd/mcpi/maximo-cpi-deployment-sa.yaml
new file mode 100644
index 0000000..91edc8c
--- /dev/null
+++ b/pd/mcpi/maximo-cpi-deployment-sa.yaml
@@ -0,0 +1,126 @@
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+ name: maximo-cpi
+---
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+ name: mcpi
+ namespace: maximo-cpi
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+ name: mcpi-cluster-role
+rules:
+ - apiGroups: ["*"]
+ resources: ["*"]
+ verbs: ["get", "list", "watch"]
+ - apiGroups: ["*"]
+ resources: ["secrets"]
+ verbs: ["list"]
+ - nonResourceURLs: ["*"]
+ verbs: ["get"]
+ #- apiGroups: [""]
+ # resources: ["pods/exec"]
+ # verbs: ["create"]
+---
+kind: ClusterRoleBinding
+apiVersion: rbac.authorization.k8s.io/v1
+metadata:
+ name: mcpi-cluster-role-binding
+subjects:
+ - kind: ServiceAccount
+ name: mcpi
+ namespace: maximo-cpi
+roleRef:
+ kind: ClusterRole
+ name: mcpi-cluster-role
+ apiGroup: rbac.authorization.k8s.io
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+ name: mcpi-ingress-exec-access
+ namespace: openshift-ingress
+rules:
+ - apiGroups: [""]
+ resources: ["pods/exec"]
+ verbs: ["create"]
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: RoleBinding
+metadata:
+ name: mcpi-exec-access-binding
+ namespace: openshift-ingress
+subjects:
+ - kind: ServiceAccount
+ name: mcpi
+ namespace: maximo-cpi
+roleRef:
+ kind: Role
+ name: mcpi-ingress-exec-access
+ apiGroup: rbac.authorization.k8s.io
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: mcpi-deployment
+ namespace: maximo-cpi
+ labels:
+ app: mcpi
+spec:
+ replicas: 1
+ imagePullPolicy: Always
+ selector:
+ matchLabels:
+ app: mcpi
+ template:
+ metadata:
+ labels:
+ app: mcpi
+ spec:
+ #securityContext:
+ # runAsUser: 0 # no specify, the openshift uses the restricted by default
+ serviceAccountName: mcpi
+ #imagePullSecrets:
+ # - name: ibm-entitlement
+ containers:
+ - name: mcpi
+ image: quay.io/brianzhu_ibm/mcpi:latest
+ env:
+ - name: INCLUSTER
+ value: "true"
+---
+apiVersion: v1
+kind: Service
+metadata:
+ name: mcpi-service
+ namespace: maximo-cpi
+spec:
+ selector:
+ app: mcpi
+ ports:
+ - name: viewer-port
+ protocol: TCP
+ port: 8888
+ targetPort: 8888
+---
+kind: Route
+apiVersion: route.openshift.io/v1
+metadata:
+ name: mcpi-viewer-route
+ namespace: maximo-cpi
+ labels: {}
+spec:
+ to:
+ kind: Service
+ name: mcpi-service
+ weight: 100
+ port:
+ targetPort: viewer-port
+ tls:
+ termination: edge
+ wildcardPolicy: None
diff --git a/pd/mcpi/maximo-cpi-deployment.yaml b/pd/mcpi/maximo-cpi-deployment.yaml
new file mode 100644
index 0000000..6019921
--- /dev/null
+++ b/pd/mcpi/maximo-cpi-deployment.yaml
@@ -0,0 +1,66 @@
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+ name: maximo-cpi
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: mcpi-deployment
+ namespace: maximo-cpi
+ labels:
+ app: mcpi
+spec:
+ replicas: 1
+ imagePullPolicy: Always
+ selector:
+ matchLabels:
+ app: mcpi
+ template:
+ metadata:
+ labels:
+ app: mcpi
+ spec:
+ #securityContext:
+ # runAsUser: 0 # no specify, the openshift uses the restricted by default
+ # serviceAccountName: mcpi
+ #imagePullSecrets:
+ # - name: ibm-entitlement
+ containers:
+ - name: mcpi
+ image: quay.io/brianzhu_ibm/mcpi:latest
+ env:
+ - name: INCLUSTER
+ value: "true"
+---
+apiVersion: v1
+kind: Service
+metadata:
+ name: mcpi-service
+ namespace: maximo-cpi
+spec:
+ selector:
+ app: mcpi
+ ports:
+ - name: viewer-port
+ protocol: TCP
+ port: 8888
+ targetPort: 8888
+---
+kind: Route
+apiVersion: route.openshift.io/v1
+metadata:
+ name: mcpi-viewer-route
+ namespace: maximo-cpi
+ labels: {}
+spec:
+ to:
+ kind: Service
+ name: mcpi-service
+ weight: 100
+ port:
+ targetPort: viewer-port
+ tls:
+ termination: edge
+ wildcardPolicy: None
diff --git a/pd/mcpi/maximo-cpi/index.html b/pd/mcpi/maximo-cpi/index.html
new file mode 100644
index 0000000..b817e4d
--- /dev/null
+++ b/pd/mcpi/maximo-cpi/index.html
@@ -0,0 +1,343 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Coming soon ...
+
+
+Critical Note
+IBM Maximo Cluster Performance Insights is offered "AS IS", WITH NO WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING THE WARRANTY OF TITLE, NON-INFRINGEMENT OR NON-INTERFERENCE AND THE IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+The IBM Product Support you have purchased with your IBM Maximo Application Suite Product does not cover this Application extension. Do not attempt to submit an IBM support ticket.
+The IBM TechXChange Maximo Community discussions can be leveraged to crowd-source assistance from Maximo Experts.
+What is IBM Maximo Cluster Performance Insights
+IBM Maximo Cluster Performance Insights (Maximo CPI), is a new utility that use short and long term snapshots to addresses specific best practices for deployment of Maximo App Suite. It can assist in pinpointing areas that need improvement and provide actionable insights for optimizing the MAS deployment.
+Maximo Clients can conduct a self-assessment to ensure adherence to best practices, optimize resource use, and diagnose performance issues. This process helps in evaluating current practices, identifying areas for improvement, and enhancing overall efficiency and effectiveness.
+The utility gathers only metrics data, excluding any sensitive information. It is containerized for ease of use.
+IBM Maximo Cluster Performance Insights Main Features
+-
+
- Identify any missing or incorrect settings that not follows MAS Best Practice +
- Offer an in-depth evaluation of the deployed MAS system's performance +
- Provide recommendations for minimizing the size of the MAS deployment to reduce infrastructure costs +
- Identify certificates that have expired or are about to expire +
- Provide suggestion for rebalancing the node resource utilization to optimize the workload +
- Capacity to send a notification via slack +
- Offer a platform for customized MAS Manage schedule scaling +
User guide
+-
+
-
+
Run on Docker
+-
+
- Download the docker container:
docker pull quay.io/brianzhu_ibm/mcpi:latest
+ - Run the docker container:
docker run -dit -p 8888:8888 --name mcpi quay.io/brianzhu_ibm/mcpi:latest
+ - Data Collection
-
+
- enter into the docker container:
docker exec -it --user root mcpi bash
+ - login on OpenShift Cluster:
oc login https://<openshift-master-url>:<port> -u <username> -p <password>oroc login https://<openshift-master-url>:<port> --token=<token>
+ - execute data collection command:
collect-metric.sh
+ - note: when the command finishes executing, it returns the path to the MHC JSON file. Below is a sample of the returning. In this case, the path to the MHC JSON file is /tmp/mhc-2024-08-01-19-36.json
+
+
+ - enter into the docker container:
- Data Review
-
+
- launch the mcpi viewer url (http://localhost:8888) in the browser +
- review the data: Under Load a MAS Harmony Checker JSON file from the server's path, enter the path to the MHC JSON file e.g. /tmp/mhc-2024-08-01-19-36.json Below is the sample snapshot
+
+
+
+ - Download the docker container:
-
+
Run on OpenShift Cluster
+-
+
- Download maximo-cpi-deployment.yaml +
- Login on OpenShift Cluster Console +
- Click + to import YAML, then Drag and drop maximo-cpi-deployment.yaml +
- Data Collection
-
+
- login into the cluster console +
- go to maximo-cpi project +
- click on mcpi-deployment-xxx pod +
- go to Terminal tab
-
+
- login on OpenShift Cluster:
oc login https://<openshift-master-url>:<port> -u <username> -p <password>oroc login https://<openshift-master-url>:<port> --token=<token>
+ - execute data collection command:
collect-metric.sh
+ - note: when the command finishes executing, it returns the path to the MHC JSON file. See the sample in the Run on Docker section +
+ - login on OpenShift Cluster:
+ - Data Review
-
+
- go to maximo-cpi project -> Networking -> Routes +
- click on mcpi-viewer-route url +
- review the data: Under Load a MAS Harmony Checker JSON file from the server's path, enter the path to the MHC JSON file e.g. /tmp/mhc-2024-08-01-19-36.json See the sample in the Run on Docker section +
+
+
Most Common User Scenarios
+1) Best practice to minimizing footprint through Maximo CPI
+-
+
- Step 1: Eliminate the surplus nodes if exist +
- Step 2: Balance CPU and Memory Request%; Align CPU and Memory Requests to match hardware specifications, such as a ratio of 1:4 or 1:8. +
- Step 3: Continuously reduce the resource requests for pods/containers to enhance utilization. Ideally, aim for resource utilization that exceeds the resource requests and approaches 60–70% of the cluster capacity. +
- Repeat Step 1 – 3 if needed +
2) Best practice for performance troubleshooting and configuration checking
+-
+
- Step 1: Heatmap viewer provides the problematic pods and nodes +
- Step 2: Maximo CPI viewer provides the metric details +
- Step 3: Identify the severity and functional impacts +
- Step 4: Vertically and horizontally adjust the pod/service/node and apply the recommended OpenShift Configuration if needed +
- Repeat Step 1 – 4 if needed +
3) Rebalance Node Resource
+-
+
- Issue Description: Observe the unbalance resource usage among the nodes. E.g. some nodes use 80% cpu, but the other uses 20% cpu. +
- Reason: Imbalanced placement OpenShift schedules the service / pod based on the resource cost increment , not the real resource usage. +
- Solution: migrate pods from busy nodes to non-busy nodes with min movements. This is a typical bin-packing (NP-Hard) problem. Maximo CPI uses the greedy algorithm since the time and minimum steps are not critical. +
- Actions: ⚠️ Moving pods can be disruptive at times, as it may cause an outage while the stateful service pod is being relocated.
-
+
- execute node-balance.sh. The output will provide movepod command if any issue is detected +
- execute movepod.sh to move the pods. +
+
4) Scheduled Scaling
+-
+
- modify mas-manage-scheduled-scaling-sample.sh to adjust the parameters e.g. time and pod replica number +
- set up the slack url and channel name for notification if needed +
5) Expired and Expiring Certificate
+-
+
- modify cert-expiration-slack-alert-sample.sh to adjust the paramenter e.g. time and expiration-in-days +
- set up the slack url and channel name for notification if needed +
Upcoming
+-
+
- Release this utility to the public via IBM Accelerator +
- Extend metric collection to cover the database performance metrics +
- Add and enhance the policies for alerting and best practices +
- Enhance MAS Optimization, Sizing, Re-balance, Scaling, Performance Diagnosis via AI technology +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pd/mcpi/mcpi-deployment.yaml b/pd/mcpi/mcpi-deployment.yaml
new file mode 100644
index 0000000..6019921
--- /dev/null
+++ b/pd/mcpi/mcpi-deployment.yaml
@@ -0,0 +1,66 @@
+---
+apiVersion: v1
+kind: Namespace
+metadata:
+ name: maximo-cpi
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: mcpi-deployment
+ namespace: maximo-cpi
+ labels:
+ app: mcpi
+spec:
+ replicas: 1
+ imagePullPolicy: Always
+ selector:
+ matchLabels:
+ app: mcpi
+ template:
+ metadata:
+ labels:
+ app: mcpi
+ spec:
+ #securityContext:
+ # runAsUser: 0 # no specify, the openshift uses the restricted by default
+ # serviceAccountName: mcpi
+ #imagePullSecrets:
+ # - name: ibm-entitlement
+ containers:
+ - name: mcpi
+ image: quay.io/brianzhu_ibm/mcpi:latest
+ env:
+ - name: INCLUSTER
+ value: "true"
+---
+apiVersion: v1
+kind: Service
+metadata:
+ name: mcpi-service
+ namespace: maximo-cpi
+spec:
+ selector:
+ app: mcpi
+ ports:
+ - name: viewer-port
+ protocol: TCP
+ port: 8888
+ targetPort: 8888
+---
+kind: Route
+apiVersion: route.openshift.io/v1
+metadata:
+ name: mcpi-viewer-route
+ namespace: maximo-cpi
+ labels: {}
+spec:
+ to:
+ kind: Service
+ name: mcpi-service
+ weight: 100
+ port:
+ targetPort: viewer-port
+ tls:
+ termination: edge
+ wildcardPolicy: None
diff --git a/pd/pingtest/index.html b/pd/pingtest/index.html
new file mode 100644
index 0000000..0444866
--- /dev/null
+++ b/pd/pingtest/index.html
@@ -0,0 +1,268 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ping test Utility
+When trying to diagnose a request timeout problem it is helpful to rule out gateways/load balancers outside the OCP cluster. Sometimes these external +gateways can have short timeouts which are resetting a connection before the request is completed. The Ping test Utility is designed to help +diagnose this issue.
+
+
+IMPORTANT
+As of this writing the Ping test utility is not part of the base server bundle code and needs to be loaded via a customization archive. +This means that the ManageWorkspace CR needs to be updated and will require a restart of the server bundles (i.e. it will cause a disruption +while the server bundle pod is restarted).
+Updating the ManageWorkspace CR
+-
+
- Edit the ManageWorkspace CR in the MAS Manage namespace +
Single Customization Archive +
spec:
+ settings:
+ customization:
+ customizationArchive: https://ibm.box.com/shared/static/oj9z062b7x8hcywndnv6n57gya7e1ypz.zip
+In case you already have a customization archive add to the customizationList
+
spec:
+ settings:
+ customizationList:
+ - customizationArchiveName: archiveAlias1
+ customizationArchiveUrl: https://ibm.box.com/shared/static/oj9z062b7x8hcywndnv6n57gya7e1ypz.zip
+-
+
- Wait for the MAS Manage workspace operator to update the server bundle pods with the Ping servlet class and restart the server bundle pods +
Using the Ping servlet utility to test request timeouts outside the OCP cluster
+-
+
- Run the following curl command outside the OCP cluster using the external hostname of the MAS Manage server bundle pod. The command below will send + a request to the Ping servlet which will wait for 1 second before responding. If a response is returned it means no timeout occurred. +
$ curl https://tenant1.manage.masperf4.ibmmas.com/maximo/ping?timeout=1
+{"thread wait time":"1 seconds","status":"ok"}
+$
+-
+
- Change the timeout value to match the timeout that you are observing in problematic request. For example, the Ping request below sets a timeout of 300
+ seconds. If no response is received it means the request timed out and the same request should be attempted from inside the OCP cluster using the private
+ IP address of the server bundle pod (see
Using the Ping servlet utility to test request timeouts inside the OCP clusterbelow).
+
$ curl https://tenant1.manage.masperf4.ibmmas.com/maximo/ping?timeout=300
+Using the Ping servlet utility to test request timeouts inside the OCP cluster
+-
+
- Obtain the internal Cluster IP address of the MAS Manage UI service. +
- Go to maxinst pod in the MAS Manage namespace -> terminal tab, then execute below commands: +
$ curl --insecure https://172.30.237.166:443/maximo/ping?timeout=300
+{"thread wait time":"300 seconds","status":"ok"}
+$
+If you receive a response from the request issued to the internal Cluster IP address of the MAS Manage UI service, but do not receive a response issued externally from outside the cluster, it could be the case that an external gateway service or load balancer is closing the connection due to a shorter timeout set on the gateway. Check is a network administrator.
+ +
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/pd/ptbp/index.html b/pd/ptbp/index.html
new file mode 100644
index 0000000..bfd5d3a
--- /dev/null
+++ b/pd/ptbp/index.html
@@ -0,0 +1,225 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ GitHub
+
+
+
+ « Previous
+
+
+ Next »
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/search.html b/search.html
new file mode 100644
index 0000000..c2336fc
--- /dev/null
+++ b/search.html
@@ -0,0 +1,202 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Search Results
+ + + +
+ Searching...
+
+
+
+
+
+
+
+ GitHub
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/search/lunr.js b/search/lunr.js
new file mode 100644
index 0000000..aca0a16
--- /dev/null
+++ b/search/lunr.js
@@ -0,0 +1,3475 @@
+/**
+ * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 2.3.9
+ * Copyright (C) 2020 Oliver Nightingale
+ * @license MIT
+ */
+
+;(function(){
+
+/**
+ * A convenience function for configuring and constructing
+ * a new lunr Index.
+ *
+ * A lunr.Builder instance is created and the pipeline setup
+ * with a trimmer, stop word filter and stemmer.
+ *
+ * This builder object is yielded to the configuration function
+ * that is passed as a parameter, allowing the list of fields
+ * and other builder parameters to be customised.
+ *
+ * All documents _must_ be added within the passed config function.
+ *
+ * @example
+ * var idx = lunr(function () {
+ * this.field('title')
+ * this.field('body')
+ * this.ref('id')
+ *
+ * documents.forEach(function (doc) {
+ * this.add(doc)
+ * }, this)
+ * })
+ *
+ * @see {@link lunr.Builder}
+ * @see {@link lunr.Pipeline}
+ * @see {@link lunr.trimmer}
+ * @see {@link lunr.stopWordFilter}
+ * @see {@link lunr.stemmer}
+ * @namespace {function} lunr
+ */
+var lunr = function (config) {
+ var builder = new lunr.Builder
+
+ builder.pipeline.add(
+ lunr.trimmer,
+ lunr.stopWordFilter,
+ lunr.stemmer
+ )
+
+ builder.searchPipeline.add(
+ lunr.stemmer
+ )
+
+ config.call(builder, builder)
+ return builder.build()
+}
+
+lunr.version = "2.3.9"
+/*!
+ * lunr.utils
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * A namespace containing utils for the rest of the lunr library
+ * @namespace lunr.utils
+ */
+lunr.utils = {}
+
+/**
+ * Print a warning message to the console.
+ *
+ * @param {String} message The message to be printed.
+ * @memberOf lunr.utils
+ * @function
+ */
+lunr.utils.warn = (function (global) {
+ /* eslint-disable no-console */
+ return function (message) {
+ if (global.console && console.warn) {
+ console.warn(message)
+ }
+ }
+ /* eslint-enable no-console */
+})(this)
+
+/**
+ * Convert an object to a string.
+ *
+ * In the case of `null` and `undefined` the function returns
+ * the empty string, in all other cases the result of calling
+ * `toString` on the passed object is returned.
+ *
+ * @param {Any} obj The object to convert to a string.
+ * @return {String} string representation of the passed object.
+ * @memberOf lunr.utils
+ */
+lunr.utils.asString = function (obj) {
+ if (obj === void 0 || obj === null) {
+ return ""
+ } else {
+ return obj.toString()
+ }
+}
+
+/**
+ * Clones an object.
+ *
+ * Will create a copy of an existing object such that any mutations
+ * on the copy cannot affect the original.
+ *
+ * Only shallow objects are supported, passing a nested object to this
+ * function will cause a TypeError.
+ *
+ * Objects with primitives, and arrays of primitives are supported.
+ *
+ * @param {Object} obj The object to clone.
+ * @return {Object} a clone of the passed object.
+ * @throws {TypeError} when a nested object is passed.
+ * @memberOf Utils
+ */
+lunr.utils.clone = function (obj) {
+ if (obj === null || obj === undefined) {
+ return obj
+ }
+
+ var clone = Object.create(null),
+ keys = Object.keys(obj)
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i],
+ val = obj[key]
+
+ if (Array.isArray(val)) {
+ clone[key] = val.slice()
+ continue
+ }
+
+ if (typeof val === 'string' ||
+ typeof val === 'number' ||
+ typeof val === 'boolean') {
+ clone[key] = val
+ continue
+ }
+
+ throw new TypeError("clone is not deep and does not support nested objects")
+ }
+
+ return clone
+}
+lunr.FieldRef = function (docRef, fieldName, stringValue) {
+ this.docRef = docRef
+ this.fieldName = fieldName
+ this._stringValue = stringValue
+}
+
+lunr.FieldRef.joiner = "/"
+
+lunr.FieldRef.fromString = function (s) {
+ var n = s.indexOf(lunr.FieldRef.joiner)
+
+ if (n === -1) {
+ throw "malformed field ref string"
+ }
+
+ var fieldRef = s.slice(0, n),
+ docRef = s.slice(n + 1)
+
+ return new lunr.FieldRef (docRef, fieldRef, s)
+}
+
+lunr.FieldRef.prototype.toString = function () {
+ if (this._stringValue == undefined) {
+ this._stringValue = this.fieldName + lunr.FieldRef.joiner + this.docRef
+ }
+
+ return this._stringValue
+}
+/*!
+ * lunr.Set
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * A lunr set.
+ *
+ * @constructor
+ */
+lunr.Set = function (elements) {
+ this.elements = Object.create(null)
+
+ if (elements) {
+ this.length = elements.length
+
+ for (var i = 0; i < this.length; i++) {
+ this.elements[elements[i]] = true
+ }
+ } else {
+ this.length = 0
+ }
+}
+
+/**
+ * A complete set that contains all elements.
+ *
+ * @static
+ * @readonly
+ * @type {lunr.Set}
+ */
+lunr.Set.complete = {
+ intersect: function (other) {
+ return other
+ },
+
+ union: function () {
+ return this
+ },
+
+ contains: function () {
+ return true
+ }
+}
+
+/**
+ * An empty set that contains no elements.
+ *
+ * @static
+ * @readonly
+ * @type {lunr.Set}
+ */
+lunr.Set.empty = {
+ intersect: function () {
+ return this
+ },
+
+ union: function (other) {
+ return other
+ },
+
+ contains: function () {
+ return false
+ }
+}
+
+/**
+ * Returns true if this set contains the specified object.
+ *
+ * @param {object} object - Object whose presence in this set is to be tested.
+ * @returns {boolean} - True if this set contains the specified object.
+ */
+lunr.Set.prototype.contains = function (object) {
+ return !!this.elements[object]
+}
+
+/**
+ * Returns a new set containing only the elements that are present in both
+ * this set and the specified set.
+ *
+ * @param {lunr.Set} other - set to intersect with this set.
+ * @returns {lunr.Set} a new set that is the intersection of this and the specified set.
+ */
+
+lunr.Set.prototype.intersect = function (other) {
+ var a, b, elements, intersection = []
+
+ if (other === lunr.Set.complete) {
+ return this
+ }
+
+ if (other === lunr.Set.empty) {
+ return other
+ }
+
+ if (this.length < other.length) {
+ a = this
+ b = other
+ } else {
+ a = other
+ b = this
+ }
+
+ elements = Object.keys(a.elements)
+
+ for (var i = 0; i < elements.length; i++) {
+ var element = elements[i]
+ if (element in b.elements) {
+ intersection.push(element)
+ }
+ }
+
+ return new lunr.Set (intersection)
+}
+
+/**
+ * Returns a new set combining the elements of this and the specified set.
+ *
+ * @param {lunr.Set} other - set to union with this set.
+ * @return {lunr.Set} a new set that is the union of this and the specified set.
+ */
+
+lunr.Set.prototype.union = function (other) {
+ if (other === lunr.Set.complete) {
+ return lunr.Set.complete
+ }
+
+ if (other === lunr.Set.empty) {
+ return this
+ }
+
+ return new lunr.Set(Object.keys(this.elements).concat(Object.keys(other.elements)))
+}
+/**
+ * A function to calculate the inverse document frequency for
+ * a posting. This is shared between the builder and the index
+ *
+ * @private
+ * @param {object} posting - The posting for a given term
+ * @param {number} documentCount - The total number of documents.
+ */
+lunr.idf = function (posting, documentCount) {
+ var documentsWithTerm = 0
+
+ for (var fieldName in posting) {
+ if (fieldName == '_index') continue // Ignore the term index, its not a field
+ documentsWithTerm += Object.keys(posting[fieldName]).length
+ }
+
+ var x = (documentCount - documentsWithTerm + 0.5) / (documentsWithTerm + 0.5)
+
+ return Math.log(1 + Math.abs(x))
+}
+
+/**
+ * A token wraps a string representation of a token
+ * as it is passed through the text processing pipeline.
+ *
+ * @constructor
+ * @param {string} [str=''] - The string token being wrapped.
+ * @param {object} [metadata={}] - Metadata associated with this token.
+ */
+lunr.Token = function (str, metadata) {
+ this.str = str || ""
+ this.metadata = metadata || {}
+}
+
+/**
+ * Returns the token string that is being wrapped by this object.
+ *
+ * @returns {string}
+ */
+lunr.Token.prototype.toString = function () {
+ return this.str
+}
+
+/**
+ * A token update function is used when updating or optionally
+ * when cloning a token.
+ *
+ * @callback lunr.Token~updateFunction
+ * @param {string} str - The string representation of the token.
+ * @param {Object} metadata - All metadata associated with this token.
+ */
+
+/**
+ * Applies the given function to the wrapped string token.
+ *
+ * @example
+ * token.update(function (str, metadata) {
+ * return str.toUpperCase()
+ * })
+ *
+ * @param {lunr.Token~updateFunction} fn - A function to apply to the token string.
+ * @returns {lunr.Token}
+ */
+lunr.Token.prototype.update = function (fn) {
+ this.str = fn(this.str, this.metadata)
+ return this
+}
+
+/**
+ * Creates a clone of this token. Optionally a function can be
+ * applied to the cloned token.
+ *
+ * @param {lunr.Token~updateFunction} [fn] - An optional function to apply to the cloned token.
+ * @returns {lunr.Token}
+ */
+lunr.Token.prototype.clone = function (fn) {
+ fn = fn || function (s) { return s }
+ return new lunr.Token (fn(this.str, this.metadata), this.metadata)
+}
+/*!
+ * lunr.tokenizer
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * A function for splitting a string into tokens ready to be inserted into
+ * the search index. Uses `lunr.tokenizer.separator` to split strings, change
+ * the value of this property to change how strings are split into tokens.
+ *
+ * This tokenizer will convert its parameter to a string by calling `toString` and
+ * then will split this string on the character in `lunr.tokenizer.separator`.
+ * Arrays will have their elements converted to strings and wrapped in a lunr.Token.
+ *
+ * Optional metadata can be passed to the tokenizer, this metadata will be cloned and
+ * added as metadata to every token that is created from the object to be tokenized.
+ *
+ * @static
+ * @param {?(string|object|object[])} obj - The object to convert into tokens
+ * @param {?object} metadata - Optional metadata to associate with every token
+ * @returns {lunr.Token[]}
+ * @see {@link lunr.Pipeline}
+ */
+lunr.tokenizer = function (obj, metadata) {
+ if (obj == null || obj == undefined) {
+ return []
+ }
+
+ if (Array.isArray(obj)) {
+ return obj.map(function (t) {
+ return new lunr.Token(
+ lunr.utils.asString(t).toLowerCase(),
+ lunr.utils.clone(metadata)
+ )
+ })
+ }
+
+ var str = obj.toString().toLowerCase(),
+ len = str.length,
+ tokens = []
+
+ for (var sliceEnd = 0, sliceStart = 0; sliceEnd <= len; sliceEnd++) {
+ var char = str.charAt(sliceEnd),
+ sliceLength = sliceEnd - sliceStart
+
+ if ((char.match(lunr.tokenizer.separator) || sliceEnd == len)) {
+
+ if (sliceLength > 0) {
+ var tokenMetadata = lunr.utils.clone(metadata) || {}
+ tokenMetadata["position"] = [sliceStart, sliceLength]
+ tokenMetadata["index"] = tokens.length
+
+ tokens.push(
+ new lunr.Token (
+ str.slice(sliceStart, sliceEnd),
+ tokenMetadata
+ )
+ )
+ }
+
+ sliceStart = sliceEnd + 1
+ }
+
+ }
+
+ return tokens
+}
+
+/**
+ * The separator used to split a string into tokens. Override this property to change the behaviour of
+ * `lunr.tokenizer` behaviour when tokenizing strings. By default this splits on whitespace and hyphens.
+ *
+ * @static
+ * @see lunr.tokenizer
+ */
+lunr.tokenizer.separator = /[\s\-]+/
+/*!
+ * lunr.Pipeline
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * lunr.Pipelines maintain an ordered list of functions to be applied to all
+ * tokens in documents entering the search index and queries being ran against
+ * the index.
+ *
+ * An instance of lunr.Index created with the lunr shortcut will contain a
+ * pipeline with a stop word filter and an English language stemmer. Extra
+ * functions can be added before or after either of these functions or these
+ * default functions can be removed.
+ *
+ * When run the pipeline will call each function in turn, passing a token, the
+ * index of that token in the original list of all tokens and finally a list of
+ * all the original tokens.
+ *
+ * The output of functions in the pipeline will be passed to the next function
+ * in the pipeline. To exclude a token from entering the index the function
+ * should return undefined, the rest of the pipeline will not be called with
+ * this token.
+ *
+ * For serialisation of pipelines to work, all functions used in an instance of
+ * a pipeline should be registered with lunr.Pipeline. Registered functions can
+ * then be loaded. If trying to load a serialised pipeline that uses functions
+ * that are not registered an error will be thrown.
+ *
+ * If not planning on serialising the pipeline then registering pipeline functions
+ * is not necessary.
+ *
+ * @constructor
+ */
+lunr.Pipeline = function () {
+ this._stack = []
+}
+
+lunr.Pipeline.registeredFunctions = Object.create(null)
+
+/**
+ * A pipeline function maps lunr.Token to lunr.Token. A lunr.Token contains the token
+ * string as well as all known metadata. A pipeline function can mutate the token string
+ * or mutate (or add) metadata for a given token.
+ *
+ * A pipeline function can indicate that the passed token should be discarded by returning
+ * null, undefined or an empty string. This token will not be passed to any downstream pipeline
+ * functions and will not be added to the index.
+ *
+ * Multiple tokens can be returned by returning an array of tokens. Each token will be passed
+ * to any downstream pipeline functions and all will returned tokens will be added to the index.
+ *
+ * Any number of pipeline functions may be chained together using a lunr.Pipeline.
+ *
+ * @interface lunr.PipelineFunction
+ * @param {lunr.Token} token - A token from the document being processed.
+ * @param {number} i - The index of this token in the complete list of tokens for this document/field.
+ * @param {lunr.Token[]} tokens - All tokens for this document/field.
+ * @returns {(?lunr.Token|lunr.Token[])}
+ */
+
+/**
+ * Register a function with the pipeline.
+ *
+ * Functions that are used in the pipeline should be registered if the pipeline
+ * needs to be serialised, or a serialised pipeline needs to be loaded.
+ *
+ * Registering a function does not add it to a pipeline, functions must still be
+ * added to instances of the pipeline for them to be used when running a pipeline.
+ *
+ * @param {lunr.PipelineFunction} fn - The function to check for.
+ * @param {String} label - The label to register this function with
+ */
+lunr.Pipeline.registerFunction = function (fn, label) {
+ if (label in this.registeredFunctions) {
+ lunr.utils.warn('Overwriting existing registered function: ' + label)
+ }
+
+ fn.label = label
+ lunr.Pipeline.registeredFunctions[fn.label] = fn
+}
+
+/**
+ * Warns if the function is not registered as a Pipeline function.
+ *
+ * @param {lunr.PipelineFunction} fn - The function to check for.
+ * @private
+ */
+lunr.Pipeline.warnIfFunctionNotRegistered = function (fn) {
+ var isRegistered = fn.label && (fn.label in this.registeredFunctions)
+
+ if (!isRegistered) {
+ lunr.utils.warn('Function is not registered with pipeline. This may cause problems when serialising the index.\n', fn)
+ }
+}
+
+/**
+ * Loads a previously serialised pipeline.
+ *
+ * All functions to be loaded must already be registered with lunr.Pipeline.
+ * If any function from the serialised data has not been registered then an
+ * error will be thrown.
+ *
+ * @param {Object} serialised - The serialised pipeline to load.
+ * @returns {lunr.Pipeline}
+ */
+lunr.Pipeline.load = function (serialised) {
+ var pipeline = new lunr.Pipeline
+
+ serialised.forEach(function (fnName) {
+ var fn = lunr.Pipeline.registeredFunctions[fnName]
+
+ if (fn) {
+ pipeline.add(fn)
+ } else {
+ throw new Error('Cannot load unregistered function: ' + fnName)
+ }
+ })
+
+ return pipeline
+}
+
+/**
+ * Adds new functions to the end of the pipeline.
+ *
+ * Logs a warning if the function has not been registered.
+ *
+ * @param {lunr.PipelineFunction[]} functions - Any number of functions to add to the pipeline.
+ */
+lunr.Pipeline.prototype.add = function () {
+ var fns = Array.prototype.slice.call(arguments)
+
+ fns.forEach(function (fn) {
+ lunr.Pipeline.warnIfFunctionNotRegistered(fn)
+ this._stack.push(fn)
+ }, this)
+}
+
+/**
+ * Adds a single function after a function that already exists in the
+ * pipeline.
+ *
+ * Logs a warning if the function has not been registered.
+ *
+ * @param {lunr.PipelineFunction} existingFn - A function that already exists in the pipeline.
+ * @param {lunr.PipelineFunction} newFn - The new function to add to the pipeline.
+ */
+lunr.Pipeline.prototype.after = function (existingFn, newFn) {
+ lunr.Pipeline.warnIfFunctionNotRegistered(newFn)
+
+ var pos = this._stack.indexOf(existingFn)
+ if (pos == -1) {
+ throw new Error('Cannot find existingFn')
+ }
+
+ pos = pos + 1
+ this._stack.splice(pos, 0, newFn)
+}
+
+/**
+ * Adds a single function before a function that already exists in the
+ * pipeline.
+ *
+ * Logs a warning if the function has not been registered.
+ *
+ * @param {lunr.PipelineFunction} existingFn - A function that already exists in the pipeline.
+ * @param {lunr.PipelineFunction} newFn - The new function to add to the pipeline.
+ */
+lunr.Pipeline.prototype.before = function (existingFn, newFn) {
+ lunr.Pipeline.warnIfFunctionNotRegistered(newFn)
+
+ var pos = this._stack.indexOf(existingFn)
+ if (pos == -1) {
+ throw new Error('Cannot find existingFn')
+ }
+
+ this._stack.splice(pos, 0, newFn)
+}
+
+/**
+ * Removes a function from the pipeline.
+ *
+ * @param {lunr.PipelineFunction} fn The function to remove from the pipeline.
+ */
+lunr.Pipeline.prototype.remove = function (fn) {
+ var pos = this._stack.indexOf(fn)
+ if (pos == -1) {
+ return
+ }
+
+ this._stack.splice(pos, 1)
+}
+
+/**
+ * Runs the current list of functions that make up the pipeline against the
+ * passed tokens.
+ *
+ * @param {Array} tokens The tokens to run through the pipeline.
+ * @returns {Array}
+ */
+lunr.Pipeline.prototype.run = function (tokens) {
+ var stackLength = this._stack.length
+
+ for (var i = 0; i < stackLength; i++) {
+ var fn = this._stack[i]
+ var memo = []
+
+ for (var j = 0; j < tokens.length; j++) {
+ var result = fn(tokens[j], j, tokens)
+
+ if (result === null || result === void 0 || result === '') continue
+
+ if (Array.isArray(result)) {
+ for (var k = 0; k < result.length; k++) {
+ memo.push(result[k])
+ }
+ } else {
+ memo.push(result)
+ }
+ }
+
+ tokens = memo
+ }
+
+ return tokens
+}
+
+/**
+ * Convenience method for passing a string through a pipeline and getting
+ * strings out. This method takes care of wrapping the passed string in a
+ * token and mapping the resulting tokens back to strings.
+ *
+ * @param {string} str - The string to pass through the pipeline.
+ * @param {?object} metadata - Optional metadata to associate with the token
+ * passed to the pipeline.
+ * @returns {string[]}
+ */
+lunr.Pipeline.prototype.runString = function (str, metadata) {
+ var token = new lunr.Token (str, metadata)
+
+ return this.run([token]).map(function (t) {
+ return t.toString()
+ })
+}
+
+/**
+ * Resets the pipeline by removing any existing processors.
+ *
+ */
+lunr.Pipeline.prototype.reset = function () {
+ this._stack = []
+}
+
+/**
+ * Returns a representation of the pipeline ready for serialisation.
+ *
+ * Logs a warning if the function has not been registered.
+ *
+ * @returns {Array}
+ */
+lunr.Pipeline.prototype.toJSON = function () {
+ return this._stack.map(function (fn) {
+ lunr.Pipeline.warnIfFunctionNotRegistered(fn)
+
+ return fn.label
+ })
+}
+/*!
+ * lunr.Vector
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * A vector is used to construct the vector space of documents and queries. These
+ * vectors support operations to determine the similarity between two documents or
+ * a document and a query.
+ *
+ * Normally no parameters are required for initializing a vector, but in the case of
+ * loading a previously dumped vector the raw elements can be provided to the constructor.
+ *
+ * For performance reasons vectors are implemented with a flat array, where an elements
+ * index is immediately followed by its value. E.g. [index, value, index, value]. This
+ * allows the underlying array to be as sparse as possible and still offer decent
+ * performance when being used for vector calculations.
+ *
+ * @constructor
+ * @param {Number[]} [elements] - The flat list of element index and element value pairs.
+ */
+lunr.Vector = function (elements) {
+ this._magnitude = 0
+ this.elements = elements || []
+}
+
+
+/**
+ * Calculates the position within the vector to insert a given index.
+ *
+ * This is used internally by insert and upsert. If there are duplicate indexes then
+ * the position is returned as if the value for that index were to be updated, but it
+ * is the callers responsibility to check whether there is a duplicate at that index
+ *
+ * @param {Number} insertIdx - The index at which the element should be inserted.
+ * @returns {Number}
+ */
+lunr.Vector.prototype.positionForIndex = function (index) {
+ // For an empty vector the tuple can be inserted at the beginning
+ if (this.elements.length == 0) {
+ return 0
+ }
+
+ var start = 0,
+ end = this.elements.length / 2,
+ sliceLength = end - start,
+ pivotPoint = Math.floor(sliceLength / 2),
+ pivotIndex = this.elements[pivotPoint * 2]
+
+ while (sliceLength > 1) {
+ if (pivotIndex < index) {
+ start = pivotPoint
+ }
+
+ if (pivotIndex > index) {
+ end = pivotPoint
+ }
+
+ if (pivotIndex == index) {
+ break
+ }
+
+ sliceLength = end - start
+ pivotPoint = start + Math.floor(sliceLength / 2)
+ pivotIndex = this.elements[pivotPoint * 2]
+ }
+
+ if (pivotIndex == index) {
+ return pivotPoint * 2
+ }
+
+ if (pivotIndex > index) {
+ return pivotPoint * 2
+ }
+
+ if (pivotIndex < index) {
+ return (pivotPoint + 1) * 2
+ }
+}
+
+/**
+ * Inserts an element at an index within the vector.
+ *
+ * Does not allow duplicates, will throw an error if there is already an entry
+ * for this index.
+ *
+ * @param {Number} insertIdx - The index at which the element should be inserted.
+ * @param {Number} val - The value to be inserted into the vector.
+ */
+lunr.Vector.prototype.insert = function (insertIdx, val) {
+ this.upsert(insertIdx, val, function () {
+ throw "duplicate index"
+ })
+}
+
+/**
+ * Inserts or updates an existing index within the vector.
+ *
+ * @param {Number} insertIdx - The index at which the element should be inserted.
+ * @param {Number} val - The value to be inserted into the vector.
+ * @param {function} fn - A function that is called for updates, the existing value and the
+ * requested value are passed as arguments
+ */
+lunr.Vector.prototype.upsert = function (insertIdx, val, fn) {
+ this._magnitude = 0
+ var position = this.positionForIndex(insertIdx)
+
+ if (this.elements[position] == insertIdx) {
+ this.elements[position + 1] = fn(this.elements[position + 1], val)
+ } else {
+ this.elements.splice(position, 0, insertIdx, val)
+ }
+}
+
+/**
+ * Calculates the magnitude of this vector.
+ *
+ * @returns {Number}
+ */
+lunr.Vector.prototype.magnitude = function () {
+ if (this._magnitude) return this._magnitude
+
+ var sumOfSquares = 0,
+ elementsLength = this.elements.length
+
+ for (var i = 1; i < elementsLength; i += 2) {
+ var val = this.elements[i]
+ sumOfSquares += val * val
+ }
+
+ return this._magnitude = Math.sqrt(sumOfSquares)
+}
+
+/**
+ * Calculates the dot product of this vector and another vector.
+ *
+ * @param {lunr.Vector} otherVector - The vector to compute the dot product with.
+ * @returns {Number}
+ */
+lunr.Vector.prototype.dot = function (otherVector) {
+ var dotProduct = 0,
+ a = this.elements, b = otherVector.elements,
+ aLen = a.length, bLen = b.length,
+ aVal = 0, bVal = 0,
+ i = 0, j = 0
+
+ while (i < aLen && j < bLen) {
+ aVal = a[i], bVal = b[j]
+ if (aVal < bVal) {
+ i += 2
+ } else if (aVal > bVal) {
+ j += 2
+ } else if (aVal == bVal) {
+ dotProduct += a[i + 1] * b[j + 1]
+ i += 2
+ j += 2
+ }
+ }
+
+ return dotProduct
+}
+
+/**
+ * Calculates the similarity between this vector and another vector.
+ *
+ * @param {lunr.Vector} otherVector - The other vector to calculate the
+ * similarity with.
+ * @returns {Number}
+ */
+lunr.Vector.prototype.similarity = function (otherVector) {
+ return this.dot(otherVector) / this.magnitude() || 0
+}
+
+/**
+ * Converts the vector to an array of the elements within the vector.
+ *
+ * @returns {Number[]}
+ */
+lunr.Vector.prototype.toArray = function () {
+ var output = new Array (this.elements.length / 2)
+
+ for (var i = 1, j = 0; i < this.elements.length; i += 2, j++) {
+ output[j] = this.elements[i]
+ }
+
+ return output
+}
+
+/**
+ * A JSON serializable representation of the vector.
+ *
+ * @returns {Number[]}
+ */
+lunr.Vector.prototype.toJSON = function () {
+ return this.elements
+}
+/* eslint-disable */
+/*!
+ * lunr.stemmer
+ * Copyright (C) 2020 Oliver Nightingale
+ * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt
+ */
+
+/**
+ * lunr.stemmer is an english language stemmer, this is a JavaScript
+ * implementation of the PorterStemmer taken from http://tartarus.org/~martin
+ *
+ * @static
+ * @implements {lunr.PipelineFunction}
+ * @param {lunr.Token} token - The string to stem
+ * @returns {lunr.Token}
+ * @see {@link lunr.Pipeline}
+ * @function
+ */
+lunr.stemmer = (function(){
+ var step2list = {
+ "ational" : "ate",
+ "tional" : "tion",
+ "enci" : "ence",
+ "anci" : "ance",
+ "izer" : "ize",
+ "bli" : "ble",
+ "alli" : "al",
+ "entli" : "ent",
+ "eli" : "e",
+ "ousli" : "ous",
+ "ization" : "ize",
+ "ation" : "ate",
+ "ator" : "ate",
+ "alism" : "al",
+ "iveness" : "ive",
+ "fulness" : "ful",
+ "ousness" : "ous",
+ "aliti" : "al",
+ "iviti" : "ive",
+ "biliti" : "ble",
+ "logi" : "log"
+ },
+
+ step3list = {
+ "icate" : "ic",
+ "ative" : "",
+ "alize" : "al",
+ "iciti" : "ic",
+ "ical" : "ic",
+ "ful" : "",
+ "ness" : ""
+ },
+
+ c = "[^aeiou]", // consonant
+ v = "[aeiouy]", // vowel
+ C = c + "[^aeiouy]*", // consonant sequence
+ V = v + "[aeiou]*", // vowel sequence
+
+ mgr0 = "^(" + C + ")?" + V + C, // [C]VC... is m>0
+ meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$", // [C]VC[V] is m=1
+ mgr1 = "^(" + C + ")?" + V + C + V + C, // [C]VCVC... is m>1
+ s_v = "^(" + C + ")?" + v; // vowel in stem
+
+ var re_mgr0 = new RegExp(mgr0);
+ var re_mgr1 = new RegExp(mgr1);
+ var re_meq1 = new RegExp(meq1);
+ var re_s_v = new RegExp(s_v);
+
+ var re_1a = /^(.+?)(ss|i)es$/;
+ var re2_1a = /^(.+?)([^s])s$/;
+ var re_1b = /^(.+?)eed$/;
+ var re2_1b = /^(.+?)(ed|ing)$/;
+ var re_1b_2 = /.$/;
+ var re2_1b_2 = /(at|bl|iz)$/;
+ var re3_1b_2 = new RegExp("([^aeiouylsz])\\1$");
+ var re4_1b_2 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+
+ var re_1c = /^(.+?[^aeiou])y$/;
+ var re_2 = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
+
+ var re_3 = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
+
+ var re_4 = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
+ var re2_4 = /^(.+?)(s|t)(ion)$/;
+
+ var re_5 = /^(.+?)e$/;
+ var re_5_1 = /ll$/;
+ var re3_5 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+
+ var porterStemmer = function porterStemmer(w) {
+ var stem,
+ suffix,
+ firstch,
+ re,
+ re2,
+ re3,
+ re4;
+
+ if (w.length < 3) { return w; }
+
+ firstch = w.substr(0,1);
+ if (firstch == "y") {
+ w = firstch.toUpperCase() + w.substr(1);
+ }
+
+ // Step 1a
+ re = re_1a
+ re2 = re2_1a;
+
+ if (re.test(w)) { w = w.replace(re,"$1$2"); }
+ else if (re2.test(w)) { w = w.replace(re2,"$1$2"); }
+
+ // Step 1b
+ re = re_1b;
+ re2 = re2_1b;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ re = re_mgr0;
+ if (re.test(fp[1])) {
+ re = re_1b_2;
+ w = w.replace(re,"");
+ }
+ } else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1];
+ re2 = re_s_v;
+ if (re2.test(stem)) {
+ w = stem;
+ re2 = re2_1b_2;
+ re3 = re3_1b_2;
+ re4 = re4_1b_2;
+ if (re2.test(w)) { w = w + "e"; }
+ else if (re3.test(w)) { re = re_1b_2; w = w.replace(re,""); }
+ else if (re4.test(w)) { w = w + "e"; }
+ }
+ }
+
+ // Step 1c - replace suffix y or Y by i if preceded by a non-vowel which is not the first letter of the word (so cry -> cri, by -> by, say -> say)
+ re = re_1c;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ w = stem + "i";
+ }
+
+ // Step 2
+ re = re_2;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = re_mgr0;
+ if (re.test(stem)) {
+ w = stem + step2list[suffix];
+ }
+ }
+
+ // Step 3
+ re = re_3;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = re_mgr0;
+ if (re.test(stem)) {
+ w = stem + step3list[suffix];
+ }
+ }
+
+ // Step 4
+ re = re_4;
+ re2 = re2_4;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = re_mgr1;
+ if (re.test(stem)) {
+ w = stem;
+ }
+ } else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1] + fp[2];
+ re2 = re_mgr1;
+ if (re2.test(stem)) {
+ w = stem;
+ }
+ }
+
+ // Step 5
+ re = re_5;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = re_mgr1;
+ re2 = re_meq1;
+ re3 = re3_5;
+ if (re.test(stem) || (re2.test(stem) && !(re3.test(stem)))) {
+ w = stem;
+ }
+ }
+
+ re = re_5_1;
+ re2 = re_mgr1;
+ if (re.test(w) && re2.test(w)) {
+ re = re_1b_2;
+ w = w.replace(re,"");
+ }
+
+ // and turn initial Y back to y
+
+ if (firstch == "y") {
+ w = firstch.toLowerCase() + w.substr(1);
+ }
+
+ return w;
+ };
+
+ return function (token) {
+ return token.update(porterStemmer);
+ }
+})();
+
+lunr.Pipeline.registerFunction(lunr.stemmer, 'stemmer')
+/*!
+ * lunr.stopWordFilter
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * lunr.generateStopWordFilter builds a stopWordFilter function from the provided
+ * list of stop words.
+ *
+ * The built in lunr.stopWordFilter is built using this generator and can be used
+ * to generate custom stopWordFilters for applications or non English languages.
+ *
+ * @function
+ * @param {Array} token The token to pass through the filter
+ * @returns {lunr.PipelineFunction}
+ * @see lunr.Pipeline
+ * @see lunr.stopWordFilter
+ */
+lunr.generateStopWordFilter = function (stopWords) {
+ var words = stopWords.reduce(function (memo, stopWord) {
+ memo[stopWord] = stopWord
+ return memo
+ }, {})
+
+ return function (token) {
+ if (token && words[token.toString()] !== token.toString()) return token
+ }
+}
+
+/**
+ * lunr.stopWordFilter is an English language stop word list filter, any words
+ * contained in the list will not be passed through the filter.
+ *
+ * This is intended to be used in the Pipeline. If the token does not pass the
+ * filter then undefined will be returned.
+ *
+ * @function
+ * @implements {lunr.PipelineFunction}
+ * @params {lunr.Token} token - A token to check for being a stop word.
+ * @returns {lunr.Token}
+ * @see {@link lunr.Pipeline}
+ */
+lunr.stopWordFilter = lunr.generateStopWordFilter([
+ 'a',
+ 'able',
+ 'about',
+ 'across',
+ 'after',
+ 'all',
+ 'almost',
+ 'also',
+ 'am',
+ 'among',
+ 'an',
+ 'and',
+ 'any',
+ 'are',
+ 'as',
+ 'at',
+ 'be',
+ 'because',
+ 'been',
+ 'but',
+ 'by',
+ 'can',
+ 'cannot',
+ 'could',
+ 'dear',
+ 'did',
+ 'do',
+ 'does',
+ 'either',
+ 'else',
+ 'ever',
+ 'every',
+ 'for',
+ 'from',
+ 'get',
+ 'got',
+ 'had',
+ 'has',
+ 'have',
+ 'he',
+ 'her',
+ 'hers',
+ 'him',
+ 'his',
+ 'how',
+ 'however',
+ 'i',
+ 'if',
+ 'in',
+ 'into',
+ 'is',
+ 'it',
+ 'its',
+ 'just',
+ 'least',
+ 'let',
+ 'like',
+ 'likely',
+ 'may',
+ 'me',
+ 'might',
+ 'most',
+ 'must',
+ 'my',
+ 'neither',
+ 'no',
+ 'nor',
+ 'not',
+ 'of',
+ 'off',
+ 'often',
+ 'on',
+ 'only',
+ 'or',
+ 'other',
+ 'our',
+ 'own',
+ 'rather',
+ 'said',
+ 'say',
+ 'says',
+ 'she',
+ 'should',
+ 'since',
+ 'so',
+ 'some',
+ 'than',
+ 'that',
+ 'the',
+ 'their',
+ 'them',
+ 'then',
+ 'there',
+ 'these',
+ 'they',
+ 'this',
+ 'tis',
+ 'to',
+ 'too',
+ 'twas',
+ 'us',
+ 'wants',
+ 'was',
+ 'we',
+ 'were',
+ 'what',
+ 'when',
+ 'where',
+ 'which',
+ 'while',
+ 'who',
+ 'whom',
+ 'why',
+ 'will',
+ 'with',
+ 'would',
+ 'yet',
+ 'you',
+ 'your'
+])
+
+lunr.Pipeline.registerFunction(lunr.stopWordFilter, 'stopWordFilter')
+/*!
+ * lunr.trimmer
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * lunr.trimmer is a pipeline function for trimming non word
+ * characters from the beginning and end of tokens before they
+ * enter the index.
+ *
+ * This implementation may not work correctly for non latin
+ * characters and should either be removed or adapted for use
+ * with languages with non-latin characters.
+ *
+ * @static
+ * @implements {lunr.PipelineFunction}
+ * @param {lunr.Token} token The token to pass through the filter
+ * @returns {lunr.Token}
+ * @see lunr.Pipeline
+ */
+lunr.trimmer = function (token) {
+ return token.update(function (s) {
+ return s.replace(/^\W+/, '').replace(/\W+$/, '')
+ })
+}
+
+lunr.Pipeline.registerFunction(lunr.trimmer, 'trimmer')
+/*!
+ * lunr.TokenSet
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * A token set is used to store the unique list of all tokens
+ * within an index. Token sets are also used to represent an
+ * incoming query to the index, this query token set and index
+ * token set are then intersected to find which tokens to look
+ * up in the inverted index.
+ *
+ * A token set can hold multiple tokens, as in the case of the
+ * index token set, or it can hold a single token as in the
+ * case of a simple query token set.
+ *
+ * Additionally token sets are used to perform wildcard matching.
+ * Leading, contained and trailing wildcards are supported, and
+ * from this edit distance matching can also be provided.
+ *
+ * Token sets are implemented as a minimal finite state automata,
+ * where both common prefixes and suffixes are shared between tokens.
+ * This helps to reduce the space used for storing the token set.
+ *
+ * @constructor
+ */
+lunr.TokenSet = function () {
+ this.final = false
+ this.edges = {}
+ this.id = lunr.TokenSet._nextId
+ lunr.TokenSet._nextId += 1
+}
+
+/**
+ * Keeps track of the next, auto increment, identifier to assign
+ * to a new tokenSet.
+ *
+ * TokenSets require a unique identifier to be correctly minimised.
+ *
+ * @private
+ */
+lunr.TokenSet._nextId = 1
+
+/**
+ * Creates a TokenSet instance from the given sorted array of words.
+ *
+ * @param {String[]} arr - A sorted array of strings to create the set from.
+ * @returns {lunr.TokenSet}
+ * @throws Will throw an error if the input array is not sorted.
+ */
+lunr.TokenSet.fromArray = function (arr) {
+ var builder = new lunr.TokenSet.Builder
+
+ for (var i = 0, len = arr.length; i < len; i++) {
+ builder.insert(arr[i])
+ }
+
+ builder.finish()
+ return builder.root
+}
+
+/**
+ * Creates a token set from a query clause.
+ *
+ * @private
+ * @param {Object} clause - A single clause from lunr.Query.
+ * @param {string} clause.term - The query clause term.
+ * @param {number} [clause.editDistance] - The optional edit distance for the term.
+ * @returns {lunr.TokenSet}
+ */
+lunr.TokenSet.fromClause = function (clause) {
+ if ('editDistance' in clause) {
+ return lunr.TokenSet.fromFuzzyString(clause.term, clause.editDistance)
+ } else {
+ return lunr.TokenSet.fromString(clause.term)
+ }
+}
+
+/**
+ * Creates a token set representing a single string with a specified
+ * edit distance.
+ *
+ * Insertions, deletions, substitutions and transpositions are each
+ * treated as an edit distance of 1.
+ *
+ * Increasing the allowed edit distance will have a dramatic impact
+ * on the performance of both creating and intersecting these TokenSets.
+ * It is advised to keep the edit distance less than 3.
+ *
+ * @param {string} str - The string to create the token set from.
+ * @param {number} editDistance - The allowed edit distance to match.
+ * @returns {lunr.Vector}
+ */
+lunr.TokenSet.fromFuzzyString = function (str, editDistance) {
+ var root = new lunr.TokenSet
+
+ var stack = [{
+ node: root,
+ editsRemaining: editDistance,
+ str: str
+ }]
+
+ while (stack.length) {
+ var frame = stack.pop()
+
+ // no edit
+ if (frame.str.length > 0) {
+ var char = frame.str.charAt(0),
+ noEditNode
+
+ if (char in frame.node.edges) {
+ noEditNode = frame.node.edges[char]
+ } else {
+ noEditNode = new lunr.TokenSet
+ frame.node.edges[char] = noEditNode
+ }
+
+ if (frame.str.length == 1) {
+ noEditNode.final = true
+ }
+
+ stack.push({
+ node: noEditNode,
+ editsRemaining: frame.editsRemaining,
+ str: frame.str.slice(1)
+ })
+ }
+
+ if (frame.editsRemaining == 0) {
+ continue
+ }
+
+ // insertion
+ if ("*" in frame.node.edges) {
+ var insertionNode = frame.node.edges["*"]
+ } else {
+ var insertionNode = new lunr.TokenSet
+ frame.node.edges["*"] = insertionNode
+ }
+
+ if (frame.str.length == 0) {
+ insertionNode.final = true
+ }
+
+ stack.push({
+ node: insertionNode,
+ editsRemaining: frame.editsRemaining - 1,
+ str: frame.str
+ })
+
+ // deletion
+ // can only do a deletion if we have enough edits remaining
+ // and if there are characters left to delete in the string
+ if (frame.str.length > 1) {
+ stack.push({
+ node: frame.node,
+ editsRemaining: frame.editsRemaining - 1,
+ str: frame.str.slice(1)
+ })
+ }
+
+ // deletion
+ // just removing the last character from the str
+ if (frame.str.length == 1) {
+ frame.node.final = true
+ }
+
+ // substitution
+ // can only do a substitution if we have enough edits remaining
+ // and if there are characters left to substitute
+ if (frame.str.length >= 1) {
+ if ("*" in frame.node.edges) {
+ var substitutionNode = frame.node.edges["*"]
+ } else {
+ var substitutionNode = new lunr.TokenSet
+ frame.node.edges["*"] = substitutionNode
+ }
+
+ if (frame.str.length == 1) {
+ substitutionNode.final = true
+ }
+
+ stack.push({
+ node: substitutionNode,
+ editsRemaining: frame.editsRemaining - 1,
+ str: frame.str.slice(1)
+ })
+ }
+
+ // transposition
+ // can only do a transposition if there are edits remaining
+ // and there are enough characters to transpose
+ if (frame.str.length > 1) {
+ var charA = frame.str.charAt(0),
+ charB = frame.str.charAt(1),
+ transposeNode
+
+ if (charB in frame.node.edges) {
+ transposeNode = frame.node.edges[charB]
+ } else {
+ transposeNode = new lunr.TokenSet
+ frame.node.edges[charB] = transposeNode
+ }
+
+ if (frame.str.length == 1) {
+ transposeNode.final = true
+ }
+
+ stack.push({
+ node: transposeNode,
+ editsRemaining: frame.editsRemaining - 1,
+ str: charA + frame.str.slice(2)
+ })
+ }
+ }
+
+ return root
+}
+
+/**
+ * Creates a TokenSet from a string.
+ *
+ * The string may contain one or more wildcard characters (*)
+ * that will allow wildcard matching when intersecting with
+ * another TokenSet.
+ *
+ * @param {string} str - The string to create a TokenSet from.
+ * @returns {lunr.TokenSet}
+ */
+lunr.TokenSet.fromString = function (str) {
+ var node = new lunr.TokenSet,
+ root = node
+
+ /*
+ * Iterates through all characters within the passed string
+ * appending a node for each character.
+ *
+ * When a wildcard character is found then a self
+ * referencing edge is introduced to continually match
+ * any number of any characters.
+ */
+ for (var i = 0, len = str.length; i < len; i++) {
+ var char = str[i],
+ final = (i == len - 1)
+
+ if (char == "*") {
+ node.edges[char] = node
+ node.final = final
+
+ } else {
+ var next = new lunr.TokenSet
+ next.final = final
+
+ node.edges[char] = next
+ node = next
+ }
+ }
+
+ return root
+}
+
+/**
+ * Converts this TokenSet into an array of strings
+ * contained within the TokenSet.
+ *
+ * This is not intended to be used on a TokenSet that
+ * contains wildcards, in these cases the results are
+ * undefined and are likely to cause an infinite loop.
+ *
+ * @returns {string[]}
+ */
+lunr.TokenSet.prototype.toArray = function () {
+ var words = []
+
+ var stack = [{
+ prefix: "",
+ node: this
+ }]
+
+ while (stack.length) {
+ var frame = stack.pop(),
+ edges = Object.keys(frame.node.edges),
+ len = edges.length
+
+ if (frame.node.final) {
+ /* In Safari, at this point the prefix is sometimes corrupted, see:
+ * https://github.com/olivernn/lunr.js/issues/279 Calling any
+ * String.prototype method forces Safari to "cast" this string to what
+ * it's supposed to be, fixing the bug. */
+ frame.prefix.charAt(0)
+ words.push(frame.prefix)
+ }
+
+ for (var i = 0; i < len; i++) {
+ var edge = edges[i]
+
+ stack.push({
+ prefix: frame.prefix.concat(edge),
+ node: frame.node.edges[edge]
+ })
+ }
+ }
+
+ return words
+}
+
+/**
+ * Generates a string representation of a TokenSet.
+ *
+ * This is intended to allow TokenSets to be used as keys
+ * in objects, largely to aid the construction and minimisation
+ * of a TokenSet. As such it is not designed to be a human
+ * friendly representation of the TokenSet.
+ *
+ * @returns {string}
+ */
+lunr.TokenSet.prototype.toString = function () {
+ // NOTE: Using Object.keys here as this.edges is very likely
+ // to enter 'hash-mode' with many keys being added
+ //
+ // avoiding a for-in loop here as it leads to the function
+ // being de-optimised (at least in V8). From some simple
+ // benchmarks the performance is comparable, but allowing
+ // V8 to optimize may mean easy performance wins in the future.
+
+ if (this._str) {
+ return this._str
+ }
+
+ var str = this.final ? '1' : '0',
+ labels = Object.keys(this.edges).sort(),
+ len = labels.length
+
+ for (var i = 0; i < len; i++) {
+ var label = labels[i],
+ node = this.edges[label]
+
+ str = str + label + node.id
+ }
+
+ return str
+}
+
+/**
+ * Returns a new TokenSet that is the intersection of
+ * this TokenSet and the passed TokenSet.
+ *
+ * This intersection will take into account any wildcards
+ * contained within the TokenSet.
+ *
+ * @param {lunr.TokenSet} b - An other TokenSet to intersect with.
+ * @returns {lunr.TokenSet}
+ */
+lunr.TokenSet.prototype.intersect = function (b) {
+ var output = new lunr.TokenSet,
+ frame = undefined
+
+ var stack = [{
+ qNode: b,
+ output: output,
+ node: this
+ }]
+
+ while (stack.length) {
+ frame = stack.pop()
+
+ // NOTE: As with the #toString method, we are using
+ // Object.keys and a for loop instead of a for-in loop
+ // as both of these objects enter 'hash' mode, causing
+ // the function to be de-optimised in V8
+ var qEdges = Object.keys(frame.qNode.edges),
+ qLen = qEdges.length,
+ nEdges = Object.keys(frame.node.edges),
+ nLen = nEdges.length
+
+ for (var q = 0; q < qLen; q++) {
+ var qEdge = qEdges[q]
+
+ for (var n = 0; n < nLen; n++) {
+ var nEdge = nEdges[n]
+
+ if (nEdge == qEdge || qEdge == '*') {
+ var node = frame.node.edges[nEdge],
+ qNode = frame.qNode.edges[qEdge],
+ final = node.final && qNode.final,
+ next = undefined
+
+ if (nEdge in frame.output.edges) {
+ // an edge already exists for this character
+ // no need to create a new node, just set the finality
+ // bit unless this node is already final
+ next = frame.output.edges[nEdge]
+ next.final = next.final || final
+
+ } else {
+ // no edge exists yet, must create one
+ // set the finality bit and insert it
+ // into the output
+ next = new lunr.TokenSet
+ next.final = final
+ frame.output.edges[nEdge] = next
+ }
+
+ stack.push({
+ qNode: qNode,
+ output: next,
+ node: node
+ })
+ }
+ }
+ }
+ }
+
+ return output
+}
+lunr.TokenSet.Builder = function () {
+ this.previousWord = ""
+ this.root = new lunr.TokenSet
+ this.uncheckedNodes = []
+ this.minimizedNodes = {}
+}
+
+lunr.TokenSet.Builder.prototype.insert = function (word) {
+ var node,
+ commonPrefix = 0
+
+ if (word < this.previousWord) {
+ throw new Error ("Out of order word insertion")
+ }
+
+ for (var i = 0; i < word.length && i < this.previousWord.length; i++) {
+ if (word[i] != this.previousWord[i]) break
+ commonPrefix++
+ }
+
+ this.minimize(commonPrefix)
+
+ if (this.uncheckedNodes.length == 0) {
+ node = this.root
+ } else {
+ node = this.uncheckedNodes[this.uncheckedNodes.length - 1].child
+ }
+
+ for (var i = commonPrefix; i < word.length; i++) {
+ var nextNode = new lunr.TokenSet,
+ char = word[i]
+
+ node.edges[char] = nextNode
+
+ this.uncheckedNodes.push({
+ parent: node,
+ char: char,
+ child: nextNode
+ })
+
+ node = nextNode
+ }
+
+ node.final = true
+ this.previousWord = word
+}
+
+lunr.TokenSet.Builder.prototype.finish = function () {
+ this.minimize(0)
+}
+
+lunr.TokenSet.Builder.prototype.minimize = function (downTo) {
+ for (var i = this.uncheckedNodes.length - 1; i >= downTo; i--) {
+ var node = this.uncheckedNodes[i],
+ childKey = node.child.toString()
+
+ if (childKey in this.minimizedNodes) {
+ node.parent.edges[node.char] = this.minimizedNodes[childKey]
+ } else {
+ // Cache the key for this node since
+ // we know it can't change anymore
+ node.child._str = childKey
+
+ this.minimizedNodes[childKey] = node.child
+ }
+
+ this.uncheckedNodes.pop()
+ }
+}
+/*!
+ * lunr.Index
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * An index contains the built index of all documents and provides a query interface
+ * to the index.
+ *
+ * Usually instances of lunr.Index will not be created using this constructor, instead
+ * lunr.Builder should be used to construct new indexes, or lunr.Index.load should be
+ * used to load previously built and serialized indexes.
+ *
+ * @constructor
+ * @param {Object} attrs - The attributes of the built search index.
+ * @param {Object} attrs.invertedIndex - An index of term/field to document reference.
+ * @param {Object' + noResultsText + '
'); + } +} + +function doSearch () { + var query = document.getElementById('mkdocs-search-query').value; + if (query.length > min_search_length) { + if (!window.Worker) { + displayResults(search(query)); + } else { + searchWorker.postMessage({query: query}); + } + } else { + // Clear results for short queries + displayResults([]); + } +} + +function initSearch () { + var search_input = document.getElementById('mkdocs-search-query'); + if (search_input) { + search_input.addEventListener("keyup", doSearch); + } + var term = getSearchTermFromLocation(); + if (term) { + search_input.value = term; + doSearch(); + } +} + +function onWorkerMessage (e) { + if (e.data.allowSearch) { + initSearch(); + } else if (e.data.results) { + var results = e.data.results; + displayResults(results); + } else if (e.data.config) { + min_search_length = e.data.config.min_search_length-1; + } +} + +if (!window.Worker) { + console.log('Web Worker API not supported'); + // load index in main thread + $.getScript(joinUrl(base_url, "search/worker.js")).done(function () { + console.log('Loaded worker'); + init(); + window.postMessage = function (msg) { + onWorkerMessage({data: msg}); + }; + }).fail(function (jqxhr, settings, exception) { + console.error('Could not load worker.js'); + }); +} else { + // Wrap search in a web worker + var searchWorker = new Worker(joinUrl(base_url, "search/worker.js")); + searchWorker.postMessage({init: true}); + searchWorker.onmessage = onWorkerMessage; +} diff --git a/search/search_index.json b/search/search_index.json new file mode 100644 index 0000000..d75c467 --- /dev/null +++ b/search/search_index.json @@ -0,0 +1 @@ +{"config":{"indexing":"full","lang":["en"],"min_search_length":3,"prebuild_index":false,"separator":"[\\s\\-]+"},"docs":[{"location":"","text":"Welcome to MAS Performance Wiki \uf0c1 Info This site will be updated periodically. More topics will be added soon. Lab benchmarks are not published, but can be shared upon request, with completion of an NDA. This site provides best practices, sizing and troubleshooting guidelines to improve the performance of IBM Maximo Application Suite (MAS) . Maximo 7.x Best Practices are also available on the site. Most DB configurations in the best practice are still applicable to MAS Manage app.","title":"Home"},{"location":"#welcome-to-mas-performance-wiki","text":"Info This site will be updated periodically. More topics will be added soon. Lab benchmarks are not published, but can be shared upon request, with completion of an NDA. This site provides best practices, sizing and troubleshooting guidelines to improve the performance of IBM Maximo Application Suite (MAS) . Maximo 7.x Best Practices are also available on the site. Most DB configurations in the best practice are still applicable to MAS Manage app.","title":"Welcome to MAS Performance Wiki"},{"location":"mas/aws/bestpractice/","text":"AWS \uf0c1 Instance Type \uf0c1 There are many instance types available in AWS. Based on the benchmark, recommend M5, M6 instances (e.g.M5.4xlarge) as master or worker nodes and P3, P4 as GPU nodes. Note Depending on the regions, some instances may not be available. Use AWS Pricing Calculator to check the instance availability and cost. g4dn can be used as GPU node for test/dev env, but not recommended for production env. If the application requires a good network performance, check Amazon EC2 instance network bandwidth site for more details. For production env, an instance with 10GB ethernet is recommended. Classic Load Balancer Idle Timeout \uf0c1 Each OCP cluster creates 1 class load balancer and 2 network load balancers in AWS. AWS classic load balancer has a default idle time 60 seconds. In some cases, this value is not enough for a long time transaction (e.g. asset health check notebook). Consider to adjust this value to what the application needs (e.g. 300 seconds). Also, monitoring classic load-balance performance is strongly recommend, particularly with IoT related app. (Note: Surge Queue Length's defaults to a hardcoded limit of 1024 . When queue is fully, the tcp handshake will fail) Amazon DocumentDB \uf0c1 DocumentDB is a fully managed MongoDB compatibility database. It can be used by both IBM Suite License Service (SLS) and MAS Core. However, there are functional differences between DocumentDB and MongoDB. Check this link for more details. Note: When using DocumentDB, it requires to set RetryWrite=false in SLS and Suite CRs. Amazon MSK \uf0c1 MAS supports MSK which is a fully managed apache Kafka service. Note monitor MSK performance via CloudWatch is strongly recommended. Key metrics include Disk usage by broker, CPU (User) usage by broker, Active Controller Count, Network RX packets by broker, Network TX packets by broker . define an appropriate config for Kafka, MSK and topics. e.g. retention.ms, retention.bytes, partitions and replics to support the workload. AWS Storage \uf0c1 EBS storages like gp2, gp3 are supported by OCP in AWS. Note: EBS storage is ReadWriteOnce. The volume can be mounted as read-write by a single node. io1 and io2 are SSD-based EBS that provides the higher performance. Check Amazon EBS volume types for extra info like throughput, tuning and cost. Below is a sample yaml to create io1 storageclass with 100 iopsPerGB . kind : StorageClass apiVersion : storage.k8s.io/v1 metadata : name : io1 provisioner : kubernetes.io/aws-ebs parameters : encrypted : 'true' iopsPerGB : '100' type : io1 reclaimPolicy : Delete allowVolumeExpansion : true volumeBindingMode : Immediate EFS Storage can be used as ReadWriteMany storageclass. EFS has different metered throughput modes. Bursting Throughput mode is the default. It is inexpensive, but does NOT perform well if all burst credits are used. Monitor BurstCreditBalance metric in CloudWatch. Provisioned Throughput mode is relatively expensive. It can drive up to 3 GiBps for read operations and 1 GiBps for write operations per file system More info can be found at Amazon EFS performance Self-managed OCP vs AWS ROSA \uf0c1 A self-managed OCP Cluster can be created by the installer cli tool that supports both IPI and UPI mode. It requires self maintenance and upgrades. Alternatively, ROSA is a managed Red Hat OpenShift Service. Each ROSA cluster comes with a fully managed control plane and compute nodes. Installation, management, maintenance, and upgrades are performed by Red Hat site reliability engineers (SRE) with joint Red Hat and Amazon support.","title":"AWS"},{"location":"mas/aws/bestpractice/#aws","text":"","title":"AWS"},{"location":"mas/aws/bestpractice/#instance-type","text":"There are many instance types available in AWS. Based on the benchmark, recommend M5, M6 instances (e.g.M5.4xlarge) as master or worker nodes and P3, P4 as GPU nodes. Note Depending on the regions, some instances may not be available. Use AWS Pricing Calculator to check the instance availability and cost. g4dn can be used as GPU node for test/dev env, but not recommended for production env. If the application requires a good network performance, check Amazon EC2 instance network bandwidth site for more details. For production env, an instance with 10GB ethernet is recommended.","title":"Instance Type"},{"location":"mas/aws/bestpractice/#classic-load-balancer-idle-timeout","text":"Each OCP cluster creates 1 class load balancer and 2 network load balancers in AWS. AWS classic load balancer has a default idle time 60 seconds. In some cases, this value is not enough for a long time transaction (e.g. asset health check notebook). Consider to adjust this value to what the application needs (e.g. 300 seconds). Also, monitoring classic load-balance performance is strongly recommend, particularly with IoT related app. (Note: Surge Queue Length's defaults to a hardcoded limit of 1024 . When queue is fully, the tcp handshake will fail)","title":"Classic Load Balancer Idle Timeout"},{"location":"mas/aws/bestpractice/#amazon-documentdb","text":"DocumentDB is a fully managed MongoDB compatibility database. It can be used by both IBM Suite License Service (SLS) and MAS Core. However, there are functional differences between DocumentDB and MongoDB. Check this link for more details. Note: When using DocumentDB, it requires to set RetryWrite=false in SLS and Suite CRs.","title":"Amazon DocumentDB"},{"location":"mas/aws/bestpractice/#amazon-msk","text":"MAS supports MSK which is a fully managed apache Kafka service. Note monitor MSK performance via CloudWatch is strongly recommended. Key metrics include Disk usage by broker, CPU (User) usage by broker, Active Controller Count, Network RX packets by broker, Network TX packets by broker . define an appropriate config for Kafka, MSK and topics. e.g. retention.ms, retention.bytes, partitions and replics to support the workload.","title":"Amazon MSK"},{"location":"mas/aws/bestpractice/#aws-storage","text":"EBS storages like gp2, gp3 are supported by OCP in AWS. Note: EBS storage is ReadWriteOnce. The volume can be mounted as read-write by a single node. io1 and io2 are SSD-based EBS that provides the higher performance. Check Amazon EBS volume types for extra info like throughput, tuning and cost. Below is a sample yaml to create io1 storageclass with 100 iopsPerGB . kind : StorageClass apiVersion : storage.k8s.io/v1 metadata : name : io1 provisioner : kubernetes.io/aws-ebs parameters : encrypted : 'true' iopsPerGB : '100' type : io1 reclaimPolicy : Delete allowVolumeExpansion : true volumeBindingMode : Immediate EFS Storage can be used as ReadWriteMany storageclass. EFS has different metered throughput modes. Bursting Throughput mode is the default. It is inexpensive, but does NOT perform well if all burst credits are used. Monitor BurstCreditBalance metric in CloudWatch. Provisioned Throughput mode is relatively expensive. It can drive up to 3 GiBps for read operations and 1 GiBps for write operations per file system More info can be found at Amazon EFS performance","title":"AWS Storage"},{"location":"mas/aws/bestpractice/#self-managed-ocp-vs-aws-rosa","text":"A self-managed OCP Cluster can be created by the installer cli tool that supports both IPI and UPI mode. It requires self maintenance and upgrades. Alternatively, ROSA is a managed Red Hat OpenShift Service. Each ROSA cluster comes with a fully managed control plane and compute nodes. Installation, management, maintenance, and upgrades are performed by Red Hat site reliability engineers (SRE) with joint Red Hat and Amazon support.","title":"Self-managed OCP vs AWS ROSA"},{"location":"mas/azure/bestpractice/","text":"Azure \uf0c1 Azure Storage \uf0c1 For OCP cluster, it recommends Premium File Storage, because MAS and its components need RWX (Read/Write/Many permission) storage to support a certain level high availability as well as doclink, jms storage\u2026 For External DB VM, it recommends a high-performance storage like Premium SSD or v2 or Ultra Disk . More performance metric can be found in https://learn.microsoft.com/en-us/azure/virtual-machines/disks-types.","title":"Azure"},{"location":"mas/azure/bestpractice/#azure","text":"","title":"Azure"},{"location":"mas/azure/bestpractice/#azure-storage","text":"For OCP cluster, it recommends Premium File Storage, because MAS and its components need RWX (Read/Write/Many permission) storage to support a certain level high availability as well as doclink, jms storage\u2026 For External DB VM, it recommends a high-performance storage like Premium SSD or v2 or Ultra Disk . More performance metric can be found in https://learn.microsoft.com/en-us/azure/virtual-machines/disks-types.","title":"Azure Storage"},{"location":"mas/core/bestpractice/","text":"MAS Core \uf0c1 The MAS core namespace contains several important services required for user login and authentication, application management, MAS adoption metrics, licensing, etc. To understand the insight of each service/pod functionality in MAS core, check MAS Pods Explained . Scaling MAS core for large number of concurrent users \uf0c1 The following are the key components/dependencies that require scaling as the number of concurrent MAS users grows. MongoDB (used extensively by coreidp, api-licensing, adoptionusage, and other MAS/SLS microservices) MAS core namespace: coreidp pods licencing-mediator pods coreapi pods (if users directly login to a MAS application, bypassing the Suite navigator page, this decreases the load on coreapi pods) SLS namespace: api-licensing pods k8s apiserver pods (coreapi pods issue k8s api calls to retrieve information from MAS application CRs, configmaps, etc.) Caveat The scaling guidance described below is provided from lab benchmark testing and may vary based on the differences in workload, environment, or configuration settings. MongoDB \uf0c1 MongoDB is a crucial dependency for MAS core services, if not scaled properly MongoDB can quickly become bottleneck as the number of concurrent users increases. A common symptom of an undersized MongoDB cluster is liveness probe timeouts and pod restarts of the MAS core services which depend on MongoDB (e.g. coreidp). For useful MongoDB troubleshooting commands see MongoDB Troubleshooting Key MongoDB metrics to monitor \uf0c1 The following MongoDB metrics are important to monitor Memory utilization: by default MongoDB will attempt to cache the active data set in memory (in the WiredTiger cache). If there are a large number of cache evictions or the mongod servers are oomkilled these can be indicators that the memory allocation is too small. Consider increasing the memory allocated to mongod server. CPU utilization: check that the mongod servers have not reached their allocated cpu limit Average read/write latency: average read and write latency should be under 50 milliseconds. If not it could be due to an undersized MongoDB cluster. Check that the MongoDB cluster has sufficient memory allocation and check disk performance. Lock waiters: a large number of lock waiters indicates contention on collections/documents in MongoDB Tip When using the ibm.mas_devops collection to install MAS you can optionally install Grafana with the cluster_monitoring ansible role . Once Grafana is installed via the cluster_monitoring ansible role you can then install MongoDB using the mongodb ansible role . The mongodb ansible role includes a Grafana dashboard for monitoring the MongoDB cluster. If your using a MongoDB cluster hosted by a cloud provider uses the monitoring dashboards provided by the cloud provider. Important MongoDB databases and collections \uf0c1 The following databases and collections in MongoDB are accessed frequently during user login and authentication. Database: mas_{{mas-instance-id}}_core Collection: User (user lookup during authentication) Collection: OauthToken (token creation/deletion) Database: {{sls-id}}_sls_licensing Collection: licenses (checkin/checkout licenses) Database: mas_{{mas-instance-id}}_adoptionusage Collection: users (daily adoption usage statistics) Collection: users_hourly (hourly adoption usage statistics) Scaling MongoDB community \uf0c1 The table below provides some general guidance on scaling MongoDB based on number of concurrent users and login rate. To scale MongoDB community edition you should specify the desired cpu/mem limits in the MongoDBCommunity CR. spec: statefulset: spec: template: spec: containers: - name: mongod resources: limits: cpu: