# Configure NFS on RHEL

The Network File System (NFS) is a protocol that allows you to set up storage locations on your network.
When you have NFS set up, your users can treat a remote hard drive as if it were attached to their computer, just like they might a USB thumbdrive.
It's one of the easiest and most transparent ways to handle shared storage within an organization.

## Install NFS

NFS is a builtin function of RHEL 9, but there's a package of utilities that you can install on both the computer serving as the NFS host, as well as on Linux workstations that are going to interface with NFS:

```bash
$ sudo dnf install nfs-utils
```

On your NFS host, enable and start the NFS service:

```bash
$ sudo systemctl enable --now nfs-server
```

Additionally, you must start the rpcbind service, which NFS uses for port mapping:

```bash
$ sudo systemctl enable --now rpcbind
```

## Set a shared location

On your NFS host, create a location on the filesystem to share with client computers.
This could be a separate drive, a separate partition, or just a place on your server.
To ensure that your storage can scale as needed, I recommend [using LVM](https://www.redhat.com/sysadmin/creating-logical-volumes).

```bash
$ sudo mkdir -p /nfs/exports/myshare
```

## Export the shared location

So that the NFS service knows to broadcast the existence of your `myshare` shared location, you must add the location to the `/etc/exports` file, along with the subnet you want to have access, and the global access permissions.
For example, assuming your network is 192.168.122.0/24 (with the first possible address being 192.168.122.1 and the final being 192.168.122.254), then you could do this:

```bash
$ echo "/nfs/exports/myshare 192.168.122.0/24(rw)" > /etc/exports
```

Note that there is no space between the network and the directory's access permissions.

## Set ownership

Depending on where you created your shared location, its permissions may not be suitable for all users on your network.
For instance, in this example I created `/nfs/exports/myshare` at the root partition of my server's hard drive, so the directories are all owned by the user `root`, with group `root` gaining read and execute permissions.
Unless your users are members of the `root` group, this export is of little use to them.

How you set directory permission is up to you, and depends on how you define users and groups on your systems.
It's common to manage directories by group permissions, adding users who require access to specific directories to the corresponding group.
For instance, if a user is a member of the `staff` group, then you could set your export to `staff` with permissions 775:

```bash
$ sudo chown root:staff /nfs/exports/myshare
$ sudo chmod 775 /nfs/exports/myshare
```

This grants `myshare` read, write, and execute permissions for all members of the `staff` group.

## Export the exports

The NFS server maintains a table of file systems available to clients.
To update the table, run the `exportfs` command along with the `-r` command to export all directories recursively.

```bash
$ sudo exportfs -r
```

## Firewall

For clients to reach your NFS server, you must add the NFS service to your firewall with the [firewall-cmd command](https://www.redhat.com/sysadmin/secure-linux-network-firewall-cmd):

```bash
$ sudo firewall-cmd --add-service nfs --permanent
```

Your NFS server is now active and configured for traffic.

## Client setup

Now that you've established a shared storage location on your network, you must configure your client machines to use it.

First, create a mount point for the NFS share:

```bash
[workstation]$ sudo mkdir /nfs/imports/myshare
```

And then mount the NFS volume:

```bash
[workstation]$ sudo mount -v \
-t nfs 192.168.122.17:/nfs/exports/myshare \
/nfs/imports/myshare/
```

You can make this a permanent and automatic process by adding the NFS volume to the client's `/etc/fstab` file:

```bash
192.168.122.17:/nfs/exports/myshare   /nfs/imports/myshare/  nfs  rw 0 0
```

You can verify that an NFS volume is mounted with the `mount` command:

```bash
[workstation]$ sudo mount | grep -i nfs
192.168.122.17:/nfs/exports/myshare on /nfs/imports/myshare ...
```

## Using NFS

If you've got more than one or two workstations, of course, you're not likely to set up your client machines to recognize NFS volumes by hand.
Instead, use [Ansible to automate](https://www.redhat.com/sysadmin/configuring-ansible) the configuration of your client machines, both to set up NFS shares, as well as to update configurations when required.
NFS makes shared storage easy and transparent for your users, and it helps encourage collaboration and shared data, so consider giving it a try.

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.