Mount a cluster file system

This example mounts the GFS2 (Global File System 2) cluster file system. Learn more about configuring cluster resources and cluster failure behavior in the High Availability Add-On Overview section of the Red Hat Enterprise documentation.

GFS2 (Global File System 2) is a shared-disk cluster file system. It allows multiple nodes to work simultaneously with a single file system, ensuring consistency and high performance. Learn more about GFS2 in the Global File System 2 section of the Red Hat Enterprise documentation.

The example uses the following for GFS2 to work:

corosync is an inter-node communication service that provides messaging between cluster nodes, monitors their availability, and determines quorum — the minimum required number of active nodes for safe cluster operation;
pacemaker is a cluster resource manager that manages starting, stopping, and moving resources between cluster nodes if one of them fails;
dlm is a distributed lock manager that coordinates access to shared resources in a cluster.

To mount a cluster file system:

Connect a network drive to each server.
Configure each cluster node.
Mount the cluster file system.

1. Connect a network volume to each server

Follow the instructions in Connect a network drive to a dedicated server running Linux.

2. Configure each cluster node

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

Connect to the server via SSH or the KVM console.
Open the netplan utility configuration file in the vi text editor:
```
vi /etc/netplan/50-cloud-init.yaml
```
Add IP addresses from the private range to the network interface used by the corosync service. The servers must have access to each other via these addresses. The iSCSI addresses used for connecting network drives and corocync must not overlap.
```
<eth_name>:
addresses:
    - <ip_address>
```
Specify:
- <eth_name> — name of the private network interface for the main messaging channel between cluster nodes;
- <ip_address> — private IP address of the current node in the main cluster network.
Exit the vi text editor and save your changes:
```
:wq
```
Apply the configuration:
```
netplan apply
```
Ensure that the network interfaces are configured correctly:
```
ip a
```

Install the components for setting up the cluster environment:

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

Restart the server.
Open the /etc/hosts configuration file in the vi text editor:
```
vi /etc/hosts
```
Add IP addresses and node names to /etc/hosts:
```
<ip_address_1> <node_name_1>
<ip_address_2> <node_name_2>
```
Specify:
- <ip_address_1> — main IP address of the first node in the private network;
- <node_name_1> — name of the first node in the private network, for example, node-1;
- <ip_address_2> — main IP address of the second node in the private network;
- <node_name_2> — name of the second node in the private network, for example, node-2.
Exit the vi text editor and save your changes:
```
:wq
```

2. Mount the cluster file system

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

Connect to the server via SSH or the KVM console.
Ensure that the network interfaces are configured correctly:
```
ip a
```

Install the components for setting up the cluster environment:

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

Restart the server.
Create a security key for corosync:
```
corosync-keygen
```
The key file will be saved in the /etc/corosync/authkey directory.
Distribute the key to the cluster nodes using the scp utility by running the command for each node:
```
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 in step 10.
Create a cluster:
```
pcs cluster setup <cluster_name> <node_name_1> <node_name_2>
```
Specify:
- <cluster_name> — cluster name;
- <node_name_1> — name of the current node in the private network that you specified when configuring the cluster node in step 10;
- <node_name_2> — name of the second node in the private network that you specified when configuring the cluster node in step 10.
Start the corosync and pacemaker services for all cluster nodes:
```
pcs cluster start --all
```
Make sure the cluster has switched to online status:
```
pcs status
```

Make sure the cluster parameters are configured correctly in the /etc/corosync/corosync.conf configuration file:

cat /etc/corosync/corosync.conf

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

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 you specified in step 7;
node-1 — name of the current node in the cluster network;
node-2 — name of the second node in the cluster network.

Output the network volume information:

multipath -ll

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

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 name of the network drive.

Format the network volume to the GFS2 file system:
```
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, which consists of two values and must be no more than 16 characters in total, where:
  - <cluster_name> — cluster name you specified in step 7;
  - <cluster_volume_name> — file system name;
- <number_of_cluster_nodes> — number of GFS2 file system journals, one journal per cluster node;
- <block_storage_name> — name of the network drive you obtained in step 11.
Start dlm, the cluster locking mechanism:
```
pcs resource start dlm
```
Configure the cluster behavior policy for when quorum is lost:
```
pcs property set no-quorum-policy=freeze
```
Create a mount point:
```
mkdir -p /mnt/<mount_point_name>
```
Specify <mount_point_name> — directory name where the cluster file system will be mounted.
Create a resource that the cluster will mount as a GFS2 file system on all nodes at startup:
```
crm configure primitive <resource_name> ocf:heartbeat:Filesystem device /dev/mapper/<block_storage_name> directory /mnt/<mount_point_name> fstype gfs2
```
Specify:
- <resource_name> — unique resource name within the cluster;
- <block_storage_name> — name of the network drive you obtained in step 11;
- <mount_point_name> — directory name on the network drive that you created in step 15.
Ensure that the cluster is operating correctly:
```
crm status
```
The response will show information about the cluster status. For example:
```
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 line displays the cluster designated controller. The partition with quorum state means that the cluster has reached quorum and is working properly;
- the Node List section lists the cluster nodes. The Online status means that the nodes are available and active;
- the Full List of Resources section displays the state of cluster resources. The Started status means that the resources are successfully started on the specified cluster nodes.
Make sure corosync has established a connection with other cluster nodes:
```
corosync-cfgtool -s
```
The output will display information about the corosync network connections. For example:
```
Local node ID 2, transport knet
LINK ID 0 udp
addr    = 192.168.1.23
status:
    nodeid:          1: connected
    nodeid:          2: localhost
```
Here, the Status section indicates the connection state to each cluster node:
- nodeid: 1: connected — node is available, connection established;
- nodeid: 2: localhost — current node.
Make sure the dlm cluster resource is running correctly and all cluster nodes have been discovered:
```
dlm_tool status
```
The output will display information about the status of the dlm resource. For example:
```
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 — cluster nodes are active and participating in the cluster.
Ensure that the network volume is displayed in the system and mounted at the target point:
```
lsblk
```
The response will show information about disks and their mount points. For example:
```
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 drives;
- mpatha — multipath device;
- /mnt/gfs — mount point for the GFS2 file system.
Ensure that the GFS2 file system is mounted correctly:
```
mount | grep gfs
```
The response will show information about the file system. For example:
```
/dev/mapper/mpatha on /mnt/gfs type gfs2 (rw,relatime,rgrplvb)
```
Where:
- /dev/mapper/mpatha — network drive hosting the GFS2 file system;
- /mnt/gfs — file system mount point;
- gfs2 — file system type.