> For the complete documentation index, see [llms.txt](https://docs.trilio.io/openstack/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.trilio.io/openstack/deployment/installing-on-mosk.md).

# Getting started with Trilio on MOSK

### 1] Prepare for deployment

#### 1.1] Install Helm CLI Client

Ensure the Helm CLI client is installed on the node from which you are installing Trilio for OpenStack. Skip if helm version already works.

```
curl -O https://get.helm.sh/helm-v3.17.2-linux-amd64.tar.gz
tar -zxvf helm*.tar.gz
mv linux-amd64/helm /usr/local/bin/helm
rm -rf linux-amd64 helm*.tar.gz
```

#### 1.2] (Optional) Install NFS Client Package

If you plan to use NFS as a backup target, install nfs-common on each Kubernetes node where TrilioVault is running. Skip this step for S3 backup targets.

SSH into each Kubernetes nodes which have the following labels

```
kubectl get nodes --show-labels | grep openstack-control-plane
kubectl get nodes --show-labels | grep openstack-compute
```

Run this command on the respective nodes:

```
sudo apt-get install nfs-common -y
```

#### 1.3] Install Necessary Dependencies

Run the following command on the installation node:

```
sudo apt update -y && sudo apt install make jq -y
```

### 2] Clone Helm Chart Repository

{% hint style="info" %}
Refer to the link [Resources](https://docs.trilio.io/openstack/about-trilio-for-openstack/artifacts.md) to get release specific values of the placeholder, viz `trilio_branch`.
{% endhint %}

```
git clone -b {{ trilio_branch }} https://github.com/trilioData/triliovault-cfg-scripts.git
cd triliovault-cfg-scripts/openstack-helm/trilio-openstack/
helm dep up
cd ../../../
```

### 3] Configure Container Image Tags

Select the appropriate image values file based on your MOSK setup version. Update the Trilio-OpenStack image tags accordingly.

* MOSK 25.1 → `mosk25.1.yaml`
* MOSK 26.2 → `mosk26.2.yaml`

```
vi triliovault-cfg-scripts/openstack-helm/trilio-openstack/values_overrides/mosk25.1.yaml
```

Or

```
vi triliovault-cfg-scripts/openstack-helm/trilio-openstack/values_overrides/mosk26.2.yaml
```

### 4] Create the `trilio-openstack` Namespace

To isolate `trilio-openstack` services, create a dedicated Kubernetes namespace:

```
kubectl create namespace trilio-openstack
kubectl config set-context --current --namespace=trilio-openstack
```

### 5] Label Kubernetes Nodes for TrilioVault Control Plane

Trilio for OpenStack control plane services should run on Kubernetes nodes labeled with `triliovault-control-plane=enabled`. Only nodes labeled with openstack-control-plane should be selected. For high availability, it is recommended to use three Kubernetes nodes.

#### 5.1] Retrieve the OpenStack control plane node names:

```
kubectl get nodes --show-labels | grep openstack-control-plane
```

#### 5.2] Assign the triliovault-control-plane label:

```
kubectl label nodes <NODE_NAME_1> triliovault-control-plane=enabled
kubectl label nodes <NODE_NAME_2> triliovault-control-plane=enabled
kubectl label nodes <NODE_NAME_3> triliovault-control-plane=enabled
```

#### 5.3] Verify:

```
kubectl get nodes --show-labels | grep triliovault-control-plane
```

### 6] Provide Cloud Admin Credentials in keystone.yaml

The cloud admin user in Keystone must have the admin role on the cloud domain.

```
vi triliovault-cfg-scripts/openstack-helm/trilio-openstack/values_overrides/keystone.yaml
```

* Verify and Update Network Interface Values

i] Before proceeding, ensure the correct network interface values are configured for live migration and hypervisor communication.

ii] Run the following command to inspect the live migration interface:

```
$ kubectl describe osdpl osh-dev -n openstack | grep live_migration_interface

Example output:
    live_migration_interface:  mcc-lcm

```

iii] If the value is mcc-lcm → no change needed.

iv] If the value is anything else → update it in values.yaml:

```
vi triliovault-cfg-scripts/openstack-helm/trilio-openstack/values.yaml
```

Update the following section:

```
libvirt:
  images_rbd_ceph_conf: /etc/ceph/ceph.conf
  live_migration_interface: "<output>"          # Interface used for live migration traffic
  hypervisor_host_interface: "<output>"         # Interface used for live migration traffic
```

Replace '' with the actual network interface name in your environment (e.g., mcc-lcm, tenant, tenant-v,).

### 7] Setup Internal RabbitMQ instance

```
cd triliovault-cfg-scripts/openstack-helm/trilio-openstack/utils
./create_rabbitmq.sh
```

Check RabbitMQ pod created

```
root@osh-ctrl-1:~# kubectl get pods
NAME                                                 READY   STATUS      RESTARTS   AGE
rabbitmq-server-0                                    1/1     Running     0          1m
```

### 8] Generate Configuration Values

Extract the credentials and connection details from the MOSK cluster. Run these scripts from the utils directory. Pass the Kubernetes cluster domain and the exact OpenStack public domain of this cloud. Get them from the OsDpl:

```
kubectl -n openstack get osdpl -o jsonpath='{.items[0].spec.internal_domain_name} {.items[0].spec.public_domain_name}{"\n"}'
./get_admin_creds_mosk.sh <internal_domain_name> <public_domain_name>
# example: ./get_admin_creds_mosk.sh cluster.local setup2.triliodata.demo
```

**Note:**\
i] In MOSK, the Keystone admin username is randomized. You MUST use get\_admin\_creds\_mosk.sh.

ii] MOSK 26.2: use the cloud's real public domain. A wrong domain still installs and answers HTTP 200. However, the T4O public endpoints in Keystone are then not covered by the gateway's \*.\<public\_domain> TLS certificate, and TLS-verifying clients fail. If that happens, uninstall and reinstall with the right domain.

iii] get\_admin\_creds\_mosk.sh also syncs the MOSK nova-compute init script into the datamover templates. This consumes placeholders in templates/bin/. Before re-running it, restore them with git checkout -- ../templates/bin/.

Verify that the credentials file is created:

* Check service FQDNs
* Check TLS Certificates (if TLS enabled)

```
cat ../values_overrides/admin_creds.yaml
cat ../templates/bin/_triliovault-nova-compute.conf.tpl
```

### 9] Extract Ceph Credentials

You MUST use get\_ceph\_mosk.sh, which fetches the MOSK nova-rbd-keyring.

```
./get_ceph_mosk.sh
```

Verify that the output is correctly written to:

```
cat ../values_overrides/ceph.yaml
cat ../templates/bin/_triliovault-ceph.conf.tpl
```

If output is incorrect; perform manual steps:

i] Edit the Ceph configuration file Set rbd\_user and keyring (the user should have read/write access to the Nova/Cinder pools). By default, the cinder/nova user usually has these permissions, but it’s recommended to verify.

```
vi ../values_overrides/ceph.yaml
```

ii] Copy your /etc/ceph/ceph.conf content to following file. Clean existing file content.

```
vi ../templates/bin/_triliovault-ceph.conf.tpl
```

### 10] Create Docker Image Pull Secret

This creates the triliovault-image-registry secret in the trilio-openstack and openstack namespaces. The Horizon plugin step uses it too.

```
./create_image_pull_secret.sh <TRILIO_REGISTRY_USERNAME> <TRILIO_REGISTRY_PASSWORD>
```

Verify that the secret has been created successfully:

```
kubectl describe secret triliovault-image-registry -n trilio-openstack
kubectl describe secret triliovault-image-registry -n openstack
```

### 11] Update install.sh

**Note: For MOSK 26.2 Gazpacho and above release use install\_mosk.sh, and for older release use install.sh**

Use the correct YAML file based on your OpenStack MOSK Version:

* MOSK 25.1 → `mosk25.1.yaml`
* MOSK 26.2 → `mosk26.2.yaml`

#### 11.1] Validate `values_overrides` Configuration

Ensure the correct configurations are used:

* Disable Ceph in `ceph.yaml` if not applicable.
* Remove `tls_public_endpoint.yaml` if TLS is unnecessary.

#### 11.2] Run the Installation Script

Execute the installation:

```
./install.sh
```

**MOSK 26.2 Gazpacho**

For MOSK 26.2 Gazpacho, change two --values lines in utils/install\_mosk.sh before installing:

Replace "--values=./trilio-openstack/values\_overrides/mosk25.1.yaml" with "--values=./trilio-openstack/values\_overrides/mosk26.2.yaml"

Replace "--values=./trilio-openstack/values\_overrides/ingress.yaml" with "--values=./trilio-openstack/values\_overrides/app\_gateway.yaml"

**Note:** i] for a MOSK 26.2 cloud that has not yet migrated to Application Gateway (still on NGINX Ingress), use ingress.yaml instead of app\_gateway.yaml.

ii] Leave every other --values line as it is.

iii] mosk26.2.yaml sets the T4O images for MOSK 26.2.

iv] app\_gateway.yaml publishes the T4O WLM and Datamover APIs through the MOSK 26.2 Application Gateway. It creates two Gateway API HTTPRoutes attached to openstack/app-gateway, instead of Ingress objects. A MOSK 26.2 cloud that has migrated to Application Gateway has no Ingress controller, so Ingress objects would never be served.

Check that the cloud is on Application Gateway:

```
kubectl -n openstack get osdpl -o jsonpath='{.items[0].spec.migration}{"\n"}'   # {"ingress":{"state":"absent"}}
kubectl -n openstack get gateway app-gateway                                     # PROGRAMMED = True
kubectl get ingressclass                                                         # No resources found
```

```
vi install_mosk.sh
```

```
./install_mosk.sh
```

The script waits for all trilio-openstack pods to reach the Running state.

**\[!TIP]** Image Pull Policy: if you see ImagePullBackOff, edit your override file and change pullPolicy from IfNotPresent to Always.

Verify the public endpoints (MOSK 26.2). Both HTTPRoutes must be accepted by the gateway:

```
kubectl -n trilio-openstack get httproute
kubectl -n trilio-openstack describe httproute | grep -E "Type:|Status:"     # Accepted=True, ResolvedRefs=True
```

Make sure triliovault-wlm.\<public\_domain\_name> and triliovault-datamover.\<public\_domain\_name> resolve to the app-gateway external IP, the same IP as the other OpenStack public endpoints:

```
kubectl -n openstack get svc app-gateway
```

### 12] Verify Installation

#### 12.1] Check Helm Release Status

```
helm status trilio-openstack
```

#### 12.2] Validate Deployed Containers

Ensure correct image versions are used by checking container tags or SHA digests.

#### 12.3] Verify Pod Status

```
kubectl get pods -n trilio-openstack
```

Example Output:

```
# kubectl get pods
NAME                                                 READY   STATUS      RESTARTS   AGE
rabbitmq-server-0                                    1/1     Running     0          44m
triliovault-datamover-api-785697d8c7-j8dcs           1/1     Running     0          40m
triliovault-datamover-api-785697d8c7-lgzqq           1/1     Running     0          40m
triliovault-datamover-api-785697d8c7-q7scw           1/1     Running     0          40m
triliovault-datamover-db-init-rqqzm                  0/1     Completed   0          39m
triliovault-datamover-db-sync-8g85f                  0/1     Completed   0          39m
triliovault-datamover-ks-endpoints-j99cx             0/3     Completed   0          36m
triliovault-datamover-ks-service-vv5x8               0/1     Completed   0          37m
triliovault-datamover-ks-user-2zzg4                  0/1     Completed   0          35m
triliovault-datamover-openstack-compute-node-7mk9s   1/1     Running     0          40m
triliovault-datamover-openstack-compute-node-sfdbr   1/1     Running     0          40m
triliovault-datamover-openstack-compute-node-txrc6   1/1     Running     0          40m
triliovault-datamover-rabbit-init-n2zjc              0/1     Completed   0          38m
triliovault-dms-5b8c4784f8-9qvrc                     1/1     Running     0          40m
triliovault-dms-5b8c4784f8-t864r                     1/1     Running     0          40m
triliovault-dms-5b8c4784f8-vmwnf                     1/1     Running     0          40m
triliovault-dms-openstack-compute-node-25bq6         1/1     Running     0          40m
triliovault-dms-openstack-compute-node-8b9pf         1/1     Running     0          40m
triliovault-dms-openstack-compute-node-9f5kc         1/1     Running     0          40m
triliovault-wlm-api-597784f5b5-7dtwk                 1/1     Running     0          40m
triliovault-wlm-api-597784f5b5-7xxt5                 1/1     Running     0          40m
triliovault-wlm-api-597784f5b5-w68g6                 1/1     Running     0          40m
triliovault-wlm-cron-57c8bf4fbc-47zls                1/1     Running     0          40m
triliovault-wlm-db-init-zfrbv                        0/1     Completed   0          39m
triliovault-wlm-db-sync-g7tp7                        0/1     Completed   0          38m
triliovault-wlm-ks-endpoints-znrkj                   0/3     Completed   0          35m
triliovault-wlm-ks-service-597lx                     0/1     Completed   0          36m
triliovault-wlm-ks-user-fxjc7                        0/1     Completed   0          34m
triliovault-wlm-rabbit-init-cgfnc                    0/1     Completed   0          37m
triliovault-wlm-scheduler-765f6f997b-692ww           1/1     Running     0          40m
triliovault-wlm-workloads-769d5b57cb-42hjw           1/1     Running     0          40m
triliovault-wlm-workloads-769d5b57cb-j8sh5           1/1     Running     0          40m
triliovault-wlm-workloads-769d5b57cb-mwbhx           1/1     Running     0          40m
```

**12.4] Check Job Completion**

```
kubectl get jobs -n trilio-openstack
```

Example Output:

```
root@mosksetup2:~# kubectl get jobs
NAME                                 STATUS     COMPLETIONS   DURATION   AGE
triliovault-datamover-db-init        Complete   1/1           15s        94m
triliovault-datamover-db-sync        Complete   1/1           43s        94m
triliovault-datamover-ks-endpoints   Complete   1/1           26s        91m
triliovault-datamover-ks-service     Complete   1/1           19s        92m
triliovault-datamover-ks-user        Complete   1/1           35s        90m
triliovault-datamover-rabbit-init    Complete   1/1           18s        93m
triliovault-wlm-db-init              Complete   1/1           16s        94m
triliovault-wlm-db-sync              Complete   1/1           59s        93m
triliovault-wlm-ks-endpoints         Complete   1/1           28s        91m
triliovault-wlm-ks-service           Complete   1/1           19s        91m
triliovault-wlm-ks-user              Complete   1/1           36s        90m
triliovault-wlm-rabbit-init          Complete   1/1           15s        92m
```

### 13] Create Cloud Admin Trust

**NOTE: This step is required only for MOSK 26.2 Gazpacho release**

MOSK uses a randomized admin username, so read it from your OpenRC file when you create the trust.

```
# Get the name of the WLM API Pod
WLM_POD=$(kubectl get pods -n trilio-openstack -l component=wlm-api -o jsonpath="{.items[0].metadata.name}")

# Execute into the pod
kubectl exec -it -n trilio-openstack $WLM_POD -- bash

# Force internal routing and source credentials
export OS_ENDPOINT_TYPE=internal
source /tmp/admin-openrc.sh

# Create the cloud Trust
workloadmgr --insecure trust-create --is_cloud_trust True admin
```

**Note (MOSK 26.2):** the public \*.\<public\_domain\_name> names usually cannot be resolved inside the cluster. If you get HTTPSConnectionPool(host='keystone.\<public\_domain>' …): Name or service not known, point the CLI at the internal Keystone endpoint after sourcing the OpenRC file:

```
export OS_AUTH_URL=<OS_AUTH_URL>
export OS_INTERFACE=internal
export OS_ENDPOINT_TYPE=internalURL
```

### 14] Add Backup Targets

To add a new backup target, refer to the [Add a new backup target](https://docs.trilio.io/openstack/admin-guide/backup-targets/add-a-backup-target.md).

### 15] Install Trilio Horizon Plugin

**(for release below MOSK 26.2 Gazpacho)** {#install-trilio-horizon}

#### 15.1] Find horizon nodes

Run following commands to fetch hostnames and IP addresses of horizon nodes.

```
kubectl get nodes -o wide --show-labels | grep openstack-control-plane=enabled |  awk '{print $1, $6;}'
# Sample output:
-------------------
root@helm1# kubectl get nodes -o wide --show-labels | grep openstack-control-plane=enabled |  awk '{print $1, $6;}'
helm2 172.25.10.203
helm3 172.25.10.204
helm4 172.25.10.205
```

#### 15.2] SSH to above list of kubernetes nodes and run following commands. \[Run this step on all Horizon nodes]

* Prerequisites: Get following variable details
  1. `<TRILIO_DOCKER_REGISTRY_USERNAME>`, `<TRILIO_DOCKER_REGISTRY_PASSWORD>`
  2. `<TRILIOVAULT_HORIZON_PLUGIN_IMAGE_TAG>` : Please check TrilioVault release notes for TrilioVault horizon docker image tag
* ssh to all nodes using IP addresses/hostname fetched in previous step and pull TrilioVault horizon image

```
# ssh to horizon nodes
ssh <HORIZON_NODE_IP>
# Login to TrilioVault Docker Image Registry
docker login docker.io -u <TRILIO_DOCKER_REGISTRY_USERNAME> -p <TRILIO_DOCKER_REGISTRY_PASSWORD>
# Pull TrilioVault Horizon Plugin Image
docker pull docker.io/trilio/trilio-horizon-plugin-helm:<TRILIOVAULT_HORIZON_PLUGIN_IMAGE_TAG>
```

#### 15.3] Edit your 'openstackdeployment.yaml'

* Get openstack deployment yaml file.

```
## Get mosk openstack deployment resource name
kubectl -n openstack get osdpl

## Example: Here 'osh-dev' is mosk openstack deployment resource name
kubectl -n openstack get osdpl
NAME      OPENSTACK   AGE    DRAFT
osh-dev   victoria    243d

## Get it's resource definition file in yaml format.
kubectl -n openstack get osdpl ${OSDPL_RESOURCE_NAME} -o yaml > openstackdeployment.yaml
## Example
kubectl -n openstack get osdpl osh-dev -o yaml > openstackdeployment.yaml
```

* Edit your `openstackdeployment.yaml` and add following block under “spec->services” block. Set correct image tag for horizon plugin image here.

```
  services:
    dashboard:
      horizon:
        values:
          images:
            tags:
              horizon: docker.io/trilio/trilio-horizon-plugin-helm:<TRILIOVAULT_HORIZON_PLUGIN_IMAGE_TAG>
```

#### 15.4] Update the openstack cloud

```
kubectl apply -f openstackdeployment.yaml
```

#### 15.5] Check status of deployment:

STATE should be APPLIED.

```
kubectl -n openstack get osdplst
##Sample output of update completed state:
--------------------------------------------
root@helm1:# kubectl -n openstack get osdplst
NAME      OPENSTACK VERSION   CONTROLLER VERSION   STATE
osh-dev   victoria            0.8.3                APPLIED
```

* Verify that horizon pods are in running state.

```
kubectl get pods -n openstack | grep horizon
## Sample output
root@helm1:# kubectl get pods -n openstack | grep horizon
horizon-f9d4c747d-8wmzt                                        1/1     Running     0          4d20h
horizon-f9d4c747d-lhplg                                        1/1     Running     0          4d19h
```

Installation of triliovault horizon plugin is done. You can login to openstack horizon. You should see ‘Backups’ tab in openstack project space. If you are already logged in to horizon, then please logout and login again.

**For MOSK 26.2 Gazpacho release**

Use the install\_horizon\_plugin\_mosk.sh script in utils/. It pre-pulls the private plugin image on all openstack-control-plane nodes, using a short-lived DaemonSet and the triliovault-image-registry secret.

Sets the Horizon image override in the OpenStackDeployment.

Checks that the Trilio panels are enabled.

```
cd triliovault-cfg-scripts/openstack-helm/trilio-openstack/utils/
./install_horizon_plugin_mosk.sh docker.io/trilio/trilio-horizon-plugin-helm:<TRILIOVAULT_HORIZON_PLUGIN_IMAGE_TAG>
# example: ./install_horizon_plugin_mosk.sh docker.io/trilio/trilio-horizon-plugin-helm:6.2.1-mosk26.2
```

It ends with:

```
Trilio Horizon plugin installed (9 panel files enabled in horizon-...).
```

Log out of Horizon and log in again. The Backups tab appears under Project, and Backups-Admin under Admin.

### 16] Apply License

Log into the Horizon UI as the cloud admin and go to the TrilioVault License tab. Upload your tvault\_license.lic file and accept the EULA to activate the product.
