---
title: "Mount a cluster file system"
sidebar_label: "Mount a cluster file system"
sidebar_position: 6
description: "How to mount a cluster file system on a network volume"
---

import Formbricks from '@theme/MDXComponents/Formbricks'

# Mount a cluster file system

The example mounts a GFS2 (Global File System 2) cluster file system. For more information about configuring cluster resources and cluster behavior during failures, see the [High Availability Add-On Overview](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/high_availability_add-on_overview/index) section of the Red Hat Enterprise documentation.

GFS2 (Global File System 2) is a cluster file system that provides shared access to data. It allows multiple nodes to work with the same file system simultaneously, ensuring consistency and high performance. For more information about GFS2, see the [Global File System 2](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/global_file_system_2/) section of the Red Hat Enterprise documentation.

The example uses the following for GFS2 to work:

* `corosync` — an inter-node communication service that ensures messaging between cluster nodes, monitors their availability, and determines a quorum—the minimum number of active nodes required for the cluster to operate safely;
* `pacemaker` — a cluster resource manager that manages starting, stopping, and moving resources between cluster nodes in the event of an individual node failure;
* `dlm` — a distributed lock manager that coordinates access to shared resources within the cluster.

To mount a cluster file system:

1. [Connect a network volume to each server](#connect-block-storage-to-each-server).
2. [Configure each cluster node](#configure-each-node-in-cluster).
3. [Mount the cluster file system](#mount-cluster-file-system).

## 1. Connect a network volume to each server \{#connect-block-storage-to-each-server}

Use the [Connect a network volume to a dedicated Linux server](/block-storage/manage/connect-block-storage-to-linux.mdx). guide.

## 2. Configure each cluster node \{#configure-each-node-in-cluster}

To ensure your nodes work together in a cluster, configure each node.

1. Connect to the server via [SSH](/dedicated/manage/connect-to-server.mdx#connect-via-ssh) or the [KVM console](/dedicated/manage/connect-to-server.mdx#connect-via-kvm-console).

2. Open the `netplan` utility configuration file with the `vi`:

   ```bash
   vi /etc/netplan/50-cloud-init.yaml
   ```

3. On the network interface used for the `corosync` service, add IP addresses from the private range. Servers must be able to access each other using these addresses. The iSCSI addresses used to connect network volumes, and `corocync` must not overlap.

   ```bash
   <eth_name>:
   addresses:
       - <ip_address>
   ```

   Specify:

   * `<eth_name>` — the name of the private network interface for the primary channel of communication between cluster nodes;
   * `<ip_address>` — the private IP address of the current node in the main cluster network.

4. Exit the `vi` text editor with your changes saved:

   ```bash
   :wq
   ```

5. Apply the configuration:

   ```bash
   netplan apply
   ```

6. Ensure that the network interfaces are configured correctly:

   ```bash
   ip a
   ```

7. Install the components for setting up the cluster environment:

   ```bash
   apt install corosync pacemaker gfs2-utils pcs resource-agents ldmtool dlm-controld
   ```

8. Restart the server.

9. Open the `/etc/hosts` configuration file with the `vi`:

   ```bash
   vi /etc/hosts
   ```

10. Add the IP addresses and hostnames to `/etc/hosts`:

    ```bash
    <ip_address_1> <node_name_1>
    <ip_address_2> <node_name_2>
    ```

    Specify:

    * `<ip_address_1>` — the primary IP address of the first node in the private network;
    * `<node_name_1>` — the name of the first node in the private network, for example `node-1`;
    * `<ip_address_2>` — the primary IP address of the second node in the private network;
    * `<node_name_2>` — the name of the second node in the private network, for example `node-2`.

11. Exit the `vi` text editor with your changes saved:

    ```bash
    :wq
    ```

## 2. Mount the cluster file system \{#mount-cluster-file-system}

On one of the cluster nodes, configure the cluster and mount the cluster file system on the network volume.

1. Connect to the server via [SSH](/dedicated/manage/connect-to-server.mdx#connect-via-ssh) or the [KVM console](/dedicated/manage/connect-to-server.mdx#connect-via-kvm-console).

2. Ensure that the network interfaces are configured correctly:

   ```bash
   ip a
   ```

3. Install the components for setting up the cluster environment:

   ```bash
   apt install corosync pacemaker gfs2-utils pcs resource-agents ldmtool dlm-controld
   ```

4. Restart the server.

5. Create a security key for `corosync`:

   ```bash
   corosync-keygen
   ```

   The key file will be saved in the `/etc/corosync/authkey`.

6. Distribute the key to the cluster nodes using the `scp` utility, to do this, run the command for each node:

   ```bash
   scp /etc/corosync/authkey root@<node_name>:/etc/corosync/authkey
   ```

   Specify `<node_name>` — the name of the node in the private network that you specified when [configuring the cluster node](#configure-each-node-in-cluster) in step 10.

7. Create a cluster:

   ```bash
   pcs cluster setup <cluster_name> <node_name_1> <node_name_2>
   ```

   Specify:

   * `<cluster_name>` — cluster name;
   * `<node_name_1>` — the name of the current node in the private network that you specified when [configuring the cluster node](#configure-each-node-in-cluster) in step 10;
   * `<node_name_2>` — the name of the second node in the private network that you specified when [configuring the cluster node](#configure-each-node-in-cluster) in step 10.

8. Start the `corosync` and `pacemaker` services for all cluster nodes:

   ```bash
   pcs cluster start --all
   ```

9. Ensure that the cluster status is `online`:

   ```bash
   pcs status
   ```

10. Ensure that the correct cluster parameters are set in the `/etc/corosync/corosync.conf` configuration file:

    ```bash
    cat /etc/corosync/corosync.conf
    ```

    The contents of the configuration file will appear in the response. For example:

    ```bash
    totem {
        version: 2
        cluster_name: cluster_name
        transport: knet
        crypto_cipher: aes256
        crypto_hash: sha256
    }
    nodelist {
        node {
            ring0_addr: node-1
            name: node-1
            nodeid: 1
        }
        node {
            ring0_addr: node-2
            name: node-2
        nodeid: 2
        }
    }
    quorum {
        provider: corosync_votequorum
        two_node: 1
    }
    logging {
        to_logfile: yes
        logfile: /var/log/corosync/corosync.log
        to_syslog: yes
        timestamp: on
    }
    ```

    Where:

    * `cluster_name` — cluster name, which you specified in step 7;
    * `node-1` — the name of the current node in the cluster network;
    * `node-2` — the name of the second node in the cluster network.

11. Output the network volume information:

    ```bash
    multipath -ll
    ```

    The command output will display information about the devices. For example:

    ```bash
    mpatha (3600140530fab7e779fa41038a0a08f8e) dm-0 LIO-ORG,TCMU device
    size=20G features='0' hwhandler='1 alua' wp=rw
    |-+- policy='service-time 0' prio=10 status=active
    | `- 8:0:0:0 sdc 8:32 active ready running
    `-+- policy='service-time 0' prio=10 status=enabled
    `- 9:0:0:0 sdd 8:48 active ready running
    ```

    Here `mpatha` is the network volume name.

12. Format the network volume to the GFS2 file system:

    ```bash
    mkfs.gfs2 -p lock_dlm -t <cluster_name>:<cluster_volume_name> -j <number_of_cluster_nodes> /dev/mapper/<block_storage_name>
    ```

    Specify:

    * `<cluster_name>:<cluster_volume_name>` — GFS2 file system identifier within the cluster, it consists of two values and in total must be no more than 16 characters, where:
      * `<cluster_name>` — cluster name, which you specified in step 7;
      * `<cluster_volume_name>` — file system name;
    * `<number_of_cluster_nodes>` — the number of GFS2 file system journals, one journal per each cluster node;
    * `<block_storage_name>` — the name of the network volume you obtained in step 11.

13. Run `dlm` — the cluster locking mechanism:

    ```bash
    pcs resource start dlm
    ```

14. Configure the cluster behavior policy for when quorum is lost:

    ```bash
    pcs property set no-quorum-policy=freeze
    ```

15. Create a mount point:

    ```bash
    mkdir -p /mnt/<mount_point_name>
    ```

    Specify `<mount_point_name>` — the name of the directory where the cluster file system will be mounted.

16. Create a resource that the cluster will mount as a GFS2 file system on all nodes at startup:

    ```bash
    crm configure primitive <resource_name> ocf:heartbeat:Filesystem device /dev/mapper/<block_storage_name> directory /mnt/<mount_point_name> fstype gfs2
    ```

    Specify:

    * `<resource_name>` — a unique resource name within the cluster;
    * `<block_storage_name>` — the name of the network volume you obtained in step 11;
    * `<mount_point_name>` — the name of the directory on the network volume that you created in step 15.

17. Ensure that the cluster is operating correctly:

    ```bash
    crm status
    ```

    The response will show information about the cluster status. For example:

    ```bash
    Cluster Summary:
    * Stack: corosync
    * Current DC: node-1 (version 2.1.2-ada5c3b36e2) - partition with quorum
    * Last updated: Mon Feb 10 11:58:13 2025
    * Last change:  Fri Feb  7 19:19:07 2025 by root via cibadmin on node-1
    * 2 nodes configured
    * 2 resource instances configured

    Node List:
    * Online: [ node-1 node-2 ]

    Full List of Resources:
    * dlm (ocf:pacemaker:controld):    Started [ node-1 node-2 ]
    * ClusterFS   (ocf:heartbeat:Filesystem):  Started [ node-1 node-2 ]
    ```

    Where:

    * the `Current DC` row displays the cluster controller node. The `partition with quorum` status means that the cluster has reached quorum and is operating correctly;
    * the `Node List` block lists the cluster nodes. The `Online` status means that the nodes are available and participating in operations;
    * the `Full List of Resources` block displays the cluster resource status. The `Started` status means that the resources have been successfully started on the specified cluster nodes.

18. Ensure that `corosync` has established a connection with other cluster nodes:

    ```bash
    corosync-cfgtool -s
    ```

    The response will show information about `corosync` network connections. For example:

    ```bash
    Local node ID 2, transport knet
    LINK ID 0 udp
    addr    = 192.168.1.23
    status:
        nodeid:          1: connected
        nodeid:          2: localhost
    ```

    Here in the `Status` block, the connection status to each cluster node is indicated:

    * `nodeid: 1: connected` — the node is available, the connection is established;
    * `nodeid: 2: localhost` — the current node.

19. Ensure that the `dlm` cluster resource is working correctly and all cluster nodes are detected:

    ```bash
    dlm_tool status
    ```

    The response will show information about the status of the `dlm` resource. For example:

    ```bash
    cluster nodeid 2 quorate 1 ring seq 80 80
    daemon now 234888 fence_pid 0
    node 1 M add 630 rem 212 fail 60 fence 159 at 1 1738943226
    node 2 M add 61 rem 0 fail 0 fence 0 at 0 0
    ```

    Where:

    * `quorate 1` — the cluster has reached quorum;
    * `node 1` and `node 2` with status `M` — the cluster nodes are active and participating in the cluster operation.

20. Ensure that the network volume is displayed in the system and mounted at the target point:

    ```bash
    lsblk
    ```

    The response will show information about disks and their mount points. For example:

    ```bash
    NAME     MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINTS
    ----
    sdc        8:32   0   150G  0 disk
    └─mpatha 252:0    0   150G  0 mpath /mnt/gfs
    sdd        8:48   0   150G  0 disk
    └─mpatha 252:0    0   150G  0 mpath /mnt/gfs
    ```

    Where:

    * `sdc`, `sdd` — network volumes;
    * `mpatha` — a multipath device;
    * `/mnt/gfs` — the GFS2 file system mount point.

21. Ensure that the GFS2 file system is mounted correctly:

    ```bash
    mount | grep gfs
    ```

    The response will show information about the file system. For example:

    ```bash
    /dev/mapper/mpatha on /mnt/gfs type gfs2 (rw,relatime,rgrplvb)
    ```

    Where:

    * `/dev/mapper/mpatha` — the network volume hosting the GFS2 file system;
    * `/mnt/gfs` — the file system mount point;
    * `gfs2` — the file system type.

<Formbricks />