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.
View the configuration file name of the netplan utility:
```
ls /etc/netplan/
```
The response will show the configuration file name. For example:
```
50-cloud-init.yaml
```
Copy the configuration file name.
Open the configuration file of the netplan utility using the vi text editor:
```
vi /etc/netplan/<file_name>
```
Specify <file_name> — the configuration file name that you copied in step 2.
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 to connect network drives and corocync must not overlap.
```
<eth_name>:
addresses:
    - <ip_address>
```
Specify:
- <eth_name> — the private network interface name for the primary messaging channel between cluster nodes;
- <ip_address> — the private IP address of the current node in the primary cluster network.
Press ESC.
Exit the vi text editor saving changes:
```
:wq
```
Apply the configuration:
```
netplan apply
```
Make sure that the network interfaces are configured correctly:
```
ip a
```

Install the components for configuring the cluster environment:

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

Reboot 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> — 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.
Press ESC.
Exit the vi text editor saving changes:
```
:wq
```

2. Mount the cluster file system

Configure the cluster on one of the cluster nodes and mount the cluster file system on the network drive.

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

Install the components for configuring the cluster environment:

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

Reboot 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 private network node name 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> — the private network name of the current node that you specified when configuring the cluster node in step 12;
- <node_name_2> — the private network name of the second node that you specified when configuring the cluster node in step 12.
Start the corosync and pacemaker services for all cluster nodes:
```
pcs cluster start --all
```
Make sure that the cluster has entered the online status:
```
pcs status
```

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

cat /etc/corosync/corosync.conf

The response will show the contents of the configuration file. 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 — the cluster name that 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.

Display information about network drives:

multipath -ll

The command output will display device information. 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

Where mpatha is the network drive name.

Format the network drive 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> — the 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> — the cluster name that you specified in step 7;
  - <cluster_volume_name> — file system name;
- <number_of_cluster_nodes> — number of GFS2 file system journals, one journal for each cluster node;
- <block_storage_name> — the network drive name that you obtained in step 11.
Start dlm — distributed lock manager:
```
pcs resource start dlm
```
Configure the cluster policy for quorum loss:
```
pcs property set no-quorum-policy=freeze
```
Create a mount point:
```
mkdir -p /mnt/<mount_point_name>
```
Specify <mount_point_name> — the 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> — a unique resource name within the cluster;
- <block_storage_name> — the network drive name that you obtained in step 11;
- <mount_point_name> — the directory name on the network drive that you created in step 15.
Make sure that the cluster is operating correctly:
```
crm status
```
The response will show the cluster status information. 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:
- in the Current DC line, the cluster Designated Controller is displayed. The partition with quorum state means that the cluster has reached quorum and is operating correctly;
- in the Node List block, the cluster nodes are listed. The Online status means that the nodes are available and active;
- in the Full List of Resources block, the state of the cluster resources is displayed. The Started status means that the resources are successfully running on the specified cluster nodes.
Make sure that corosync has established a connection with the other cluster nodes:
```
corosync-cfgtool -s
```
The response will show information about 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
```
Where in the Status block, the connection status to each cluster node is displayed:
- nodeid: 1: connected — the node is available, connection established;
- nodeid: 2: localhost — current node.
Make sure that the dlm cluster resource is operating correctly and all cluster nodes are discovered:
```
dlm_tool status
```
The response will show the dlm resource status information. 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 the M status — cluster nodes are active and participating in the cluster operation.
Make sure that the network drive is displayed in the system and mounted to the required mount point:
```
lsblk
```
The response will show information about drives 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 — GFS2 file system mount point.
Make sure that the GFS2 file system is mounted correctly:
```
mount | grep gfs
```
The response will show file system information. For example:
```
/dev/mapper/mpatha on /mnt/gfs type gfs2 (rw,relatime,rgrplvb)
```
Where:
- /dev/mapper/mpatha — the network drive where the GFS2 file system is located;
- /mnt/gfs — file system mount point;
- gfs2 — file system type.