Home
MATRIXX Installation and Upgrade
Appendixes
Artemis Cloud Example Deployment
Artemis Cloud can be used as a federated ActiveMQ broker in MATRIXX deployments to provide a single broker network across multiple clusters.
Load Balancing
Artemis Cloud supports client-side load balancing. The MATRIXX applications use the ActiveMQ drivers however, so the features of the Artemis drivers, including client-side load balancing are not available. Artemis Cloud provides server-side load balancing between the pods that make up the ActiveMQ cluster. In addition to this, you can use a Kubernetes service lo balance load with a single address on the client side.

Welcome
MATRIXX Release Notes
MATRIXX Architecture
MATRIXX Installation and Upgrade
- About MATRIXX Installation and Upgrade
  MATRIXX Installation and Upgrade describes the tasks required to install MATRIXX components as containers using Kubernetes and Helm.
- Cloud Native Infrastructure Requirements
  Cloud native MATRIXX deployments have infrastructure requirements for third-party software versions, Kubernetes pod characteristics, and container characteristics. Nodes running MATRIXX components have operating system, memory, networking, and storage requirements.
- Topology Operator and Engine Operator Feature Differences
  Different MATRIXX features are supported depending on whether your installation is based on Topology Operator or Engine Operator.
- Installing MATRIXX
  A cloud native MATRIXX installation consists of containers installed with the MATRIXX Helm chart in a multi-node Kubernetes cluster (or clusters), requiring MATRIXX images and MATRIXX Engine custom resource definitions and controllers.
- Topology Operator Installation and Upgrade Examples
  These examples show how you can configure the installation of multiple MATRIXX Engines in a single namespace, multiple namespaces in a single cluster, and multiple clusters.
- Configuring MATRIXX
  MATRIXX is configured using Helm properties. Questions and answers in create_config.info files can also provide configuration using configuration sources. For information about how to configure MATRIXX, see the discussions of those topics in MATRIXX Configuration.
- Topology Operator
  The Topology Operator method of MATRIXX Engine pod management utilizes multiple custom resources (CRs) and operator pods working together to manage the installation and upgrade of multiple sub-domains and engines across Kubernetes clusters, including the loading of pricing and taxation data.
- Scaling MATRIXX
  Use Helm and Kubernetes to manually add or remove pods as necessary. You can also use Kubernetes to manage resources available to MATRIXX Engine pods.
- Network Enablers in a Kubernetes Cluster
  For Call Control Framework (CCF), only the deployment of Network Enablers (NEs) in a Kubernetes cluster is different from a standard deployment.
- Deploying Cloud Native CAMEL Gateway
  When deploying CAMEL Gateway as part of the reference architecture, you can use any namespace within the Kubernetes clusters. You can make multiple deployments into multiple namespaces, for example, to have different environments for testing and production.
- Enabling MEF Publishing
  An SSH key, used for password-less SSH login, is required to enable _glossary/mef.html publishing in Kubernetes. A secret holds the SSH private key, and the key is specified in Helm values. The SSH key allows administrators to write to a target directory in a secure manner without having to enter a passphrase.
- Encrypted Interface Engine Replay Overview
  Transport-layer security (TLS) encryption can be enabled for replay between processing and publishing pods and between engines.
- MATRIXX Reference for MongoDB
  Cloud native MATRIXX deployments support MongoDB as an event store using the MongoDB Enterprise Operator for Kubernetes.
- MATRIXX Reference for Apache Kafka
  The Event Streaming Framework provides a connector for sending event stream data to Apache Kafka. Using 5G event streaming also requires Apache Kafka, which is not provided with MATRIXX. You can use a Helm chart to install and configure Apache Kafka.
- MATRIXX Reference for Ingress
  A Kubernetes Ingress exposes HTTP and HTTPS routes from outside the cluster to services within the cluster.
- Debugging and Failure Recovery
  MATRIXX components store log files in persistent storage on the node by default, in a persistent volume (PV) at the location specified in global.storage.localStorageDir property (/home/data by default).
- Upgrading Engine Operator-Based MATRIXX Installations
  Upgrading cloud native MATRIXX has several stages.
- Migrating to Topology Operator
  This example shows migration from a MATRIXX version XXXX deployment managed by Engine Operator to a deployment managed by Topology Operator. The same approach applies when migrating from Engine Controller.
- Migration from a Bare Metal to a Cloud Native Deployment
  Migrating from a bare metal MATRIXX deployment to a cloud native deployment (from the same MATRIXX version) requires temporarily using a hybrid platform made up of components from both deployments. This hybrid environment allows migration to the cloud native deployment without disruption of services.
- The Admin Service
  Operations teams can use the Admin Service to administer a MATRIXX deployment with domain-specific commands based on the components that are installed. It allows administration of the installation without providing unrestricted direct access to the Kubernetes cluster. You can secure commands based on user roles and audit command usage.
- Uninstall MATRIXX Engine with Helm
  Use the helm uninstall command to uninstall MATRIXX Engine components installed from the Helm chart.
- Appendixes
  - Getting Version Information from Kubernetes
    You can use the kubectl command to get version and build information for MATRIXX Engine, while it is running.
  - Upgrading Kubernetes
    Upgrade Kubernetes by upgrading the cluster where the standby MATRIXX Engine is running, and then upgrading the cluster where the active MATRIXX Engine is running.
  - Customizing Helm Chart Output
    Sometimes you must modify the output of a MATRIXX Helm chart, but there is no configuration property available for the change you want to make. Changes of this kind can be made with less potential cost using Helm post rendering. A post renderer takes the output of the Helm chart in YAML format from standard input (STDIN) and makes required changes before outputting to standard output (STDOUT).
  - Example: Provide matrixx.yaml Using a ConfigMap-type Configuration Source
    In the following example, the matrixx.yaml file is provided using a ConfigMap-type configuration source.
  - Container Directories and Environment Variables
    MATRIXX containers use several directories and environment variables for configuration data, logging, and administration scripts.
  - Artemis Cloud Example Deployment
    Artemis Cloud can be used as a federated ActiveMQ broker in MATRIXX deployments to provide a single broker network across multiple clusters.
    - Installing Artemis Cloud Operator and Creating the Broker
      To implement an Artemis Cloud broker solution, first install the operator, then create the broker.
    - Creating the Queues
      Queues are created when the application first attempts to read from or write to them. You can pre-create them instead using broker properties, an Init Container, or an ActiveMQArtemisAddress custom resource (CR).
    - Persistence
      The Artemis Cloud operator enables persistence by default. This can be set explicitly in the custom resource (CR) using the spec.deploymentPlan.persistenceEnabled property as shown in the following example:
    - Load Balancing
      Artemis Cloud supports client-side load balancing. The MATRIXX applications use the ActiveMQ drivers however, so the features of the Artemis drivers, including client-side load balancing are not available. Artemis Cloud provides server-side load balancing between the pods that make up the ActiveMQ cluster. In addition to this, you can use a Kubernetes service lo balance load with a single address on the client side.
    - MATRIXX Helm Value Settings
      By default, the MATRIXX Helm chart uses the MATRIXX ActiveMQ image. To use the Artemis Cloud broker (as configured in the examples in this section), update your Helm values file as shown in the following excerpt:
    - Artemis Cloud Federation Example Configurations
      Federated Artemis Cloud brokers require slightly different configuration in each node so that they point to each other. In this example, A hypothetical "Isla Nublar" (site A) and "Isla Sorna" (site B) employ federated Artemis Cloud brokers.
  - Make Adjustments to Ensure Engine Start in Amazon EKS
    If you are running MATRIXX Engine engine on EKS version 1.30 and the Amazon Linux 2023 operating system, you must reduce the LimitNOFILE directive of the containerd service to 1048576.
MATRIXX Configuration
MATRIXX Security
MATRIXX Integration
MATRIXX Diameter Integration
MATRIXX Call Control Framework Integration
MATRIXX TM Forum Integration
MATRIXX 5G Integration
MATRIXX 5G Event Streaming
MATRIXX Event Streaming
MATRIXX Administration
MATRIXX Web App Administration
MATRIXX Monitoring and Logging
MATRIXX Policy
MATRIXX Kafka CDR Consumer
MATRIXX Pricing and Rating
MATRIXX Pay Now
MATRIXX Subscriber Management
MATRIXX Subscriber Management API
MATRIXX Business API SDK
My MATRIXX Help
MATRIXX Backoffice Customer Tool Help
MATRIXX Third-Party Licenses
Glossary

Load Balancing

Artemis Cloud supports client-side load balancing. The MATRIXX applications use the ActiveMQ drivers however, so the features of the Artemis drivers, including client-side load balancing are not available. Artemis Cloud provides server-side load balancing between the pods that make up the ActiveMQ cluster. In addition to this, you can use a Kubernetes service lo balance load with a single address on the client side.

By default, the Artemis Cloud operator creates a headless service called artemis-broker-hdls-svc. Do not use this service if load balancing is required because it sends all traffic to the same pod. For Artemis Cloud connections, create a new service that uses the same selector as the headless service. The following ClusterIP service example provides this single address:

apiVersion: v1
kind: Service
metadata:
  labels:
    ActiveMQArtemis: artemis-broker
    application: artemis-broker-app
  name: artemis-broker-exposed
spec:
  ports:
  - name: console-jolokia
    port: 8161
    protocol: TCP
    targetPort: 8161
  - name: basic
    port: 61616
    protocol: TCP
    targetPort: 61616
  - name: ampq
    port: 5672
    protocol: TCP
    targetPort: 5672
  selector:
    ActiveMQArtemis: artemis-broker
    application: artemis-broker-app
  type: CluserIP

If Artemis Cloud is installed in a separate Kubernetes cluster, use a LoadBalancer service similar to the following:

apiVersion: v1
kind: Service
metadata:
  labels:
    ActiveMQArtemis: artemis-broker
    application: artemis-broker-app
  name: artemis-broker-exposed
spec:
  ports:
  - name: console-jolokia
    port: 8161
    protocol: TCP
    targetPort: 8161
  - name: basic
    port: 61616
    protocol: TCP
    targetPort: 61616
  - name: ampq
    port: 5672
    protocol: TCP
    targetPort: 5672
  selector:
    ActiveMQArtemis: artemis-broker
    application: artemis-broker-app
  type: LoadBalancer

Create the service in the same namespace as the broker.