1. Introduction

File servers are dedicated machines responsible for storing, managing, and providing access to files for authorized clients on a computer network. In particular, the server disk (usually an HDD or SSD) stores the files instead of each individual client. However, all clients on the computer network can access the same files.

In this tutorial, we’ll learn how to set up a file server on a Linux machine with Samba and Network File System (NFS).

This guide assumes two Ubuntu 22.04 servers: one acting as a file server and the other as a client. Both servers must be connected to the same computer network.

2. Setting up a File Server With Samba

Samba is an open-source software product that’s the free implementation of the SMB (Server Message Block) protocol.

Samba is cross-platform interoperable, meaning it enables file sharing across different operating systems such as Windows, Linux, and macOS. It also has extra features such as client authentication and encryption to safeguard data.

In this section, we’ll configure Samba on the server machine to share files over the network with the client machine. Then, we’ll learn how to access the shared files on the client machine.

2.1. Install Samba

We can install Samba on the server machine using apt.

Let’s update the package repositories to ensure we install the latest versions:

$ sudo apt-get update

Then, we perform the installation:

$ sudo apt-get install samba

This command installs and starts the Samba smbd service.

To ensure security, it’s best to stop the Samba service before making configuration changes and then restart it afterward:

$ sudo systemctl stop smbd

The above command stops the Samba smbd service.

2.2. Create Samba Share Directory

On the file server machine, let’s create a directory named clientshare:

$ mkdir clientshare

Then, we create some files within:

$ cd clientshare
$ touch file1 file2

The purpose of creating these files is for testing on the client machine.

2.3. Backup Samba Configuration File

The /etc/samba/smb.conf file is the main configuration file for Samba. It contains all the directives that define how Samba operates.

The file has two main sections:

  • [global]
  • sharename]

Rather than making changes directly to the smb.conf file, we’ll rename the original to smb.conf.original:

$ sudo mv /etc/samba/smb.conf /etc/samba/smb.conf.original

Then, we create a new empty smb.conf file:

$ touch /etc/samba/smb.conf

This is a common practice before making changes to critical configuration files. In other words, renaming the original file to smb.conf.original creates a backup copy. Doing so enables us to revert to the original configuration if something goes wrong after making edits.

2.4. Set Samba Global Options

The [global] section of this file defines the server role (standalone server), user mapping for guest access, and allowed access restrictions based on the IP address subnet.

Let’s edit the smb.conf file in a text editor such as vim:

$ sudo vim /etc/samba/smb.conf

In particular, we add the the [global] configuration:

[global]
	   server role = standalone server
           map to guest = Bad User
	   usershare allow guests = yes
	   hosts allow = 192.168.0.0/16
	   hosts deny = 0.0.0.0/0

This configuration denies guest access through mapping but allows access to user shares with guest permissions enabled. Then, the network access is limited to a specific subnet (192.168.0.0/16).

Now, let’s save and exit the editor.

2.5. Test Current Configuration

However, whenever we edit the smb.conf, it’s recommended to run testparm, a Samba command-line utility to verify the syntax of the file:

$ testparm
Load smb config files from /etc/samba/smb.conf
Loaded services file OK.
Weak crypto is allowed

Server role: ROLE_STANDALONE

Press enter to see a dump of your service definitions

# Global parameters
[global]
	server role = standalone server
        map to guest = Bad User
	usershare allow guests = Yes
	idmap config * : backend = tdb
	hosts allow = 192.168.0.0/16
	hosts deny = 0.0.0.0/0

Hence, we’ve configured the [global] option for the Samba file server.

2.6. Set Samba Share Name Options

The [sharename] section creates a blueprint for a specific directory or resource we want to share with clients over the network using Samba. Additionally, multiple [sharename] sections can be present in the smb.conf file, enabling us to share various directories independently.

Let’s create a [sharename] section named testshare in the smb.conf file and add the relevant configurations:

[testshare]
	   comment = test file share
	   guest ok = yes
           path = /home/path_to_samba_share_directory
	   read only = no

The configuration specifies [testshare] as the resource to be shared. In this case, this is the Samba share directory we created in the previous section. Then, the configuration forces ownership of all files within the shared directory to the server user and group of choice. Finally, it allows access for anyone, including guest users, and grants them read and write permissions.

Again, let’s execute testparm after saving:

$ testparm
Load smb config files from /etc/samba/smb.conf
Loaded services file OK.
Weak crypto is allowed

Server role: ROLE_STANDALONE

Press enter to see a dump of your service definitions

# Global parameters
[global]
	server role = standalone server
        map to guest = Bad User
	usershare allow guests = Yes
	idmap config * : backend = tdb
	hosts allow = 192.168.0.0/16
	hosts deny = 0.0.0.0/0


[testshare]
	comment = test file share
	force group = server_group
	force user = server_user
	guest ok = Yes
	path = /home/path_to_samba_share_directory
	read only = No

The output confirms we have no error in the syntax of the smb.conf file.

2.7. Create Samba User Account

To log in from the client machine, we set up a Samba user account on the server machine:

$ smb passwd -a username

Then, we enable the created user:

$ smbpassword -e username

This completes the configurations for the Samba file server.

2.8. Access Share Directory on Client

Now, we can access the shared directory over the network with Samba.

To begin with, we install smbclient on the client:

$ sudo apt-get install smbclient

smbclient is a command-line tool that connects clients to remote directories shared by Samba servers. This tool enables us to connect to the shared directory on the Samba server.

Once it’s installed, we connect to the Samba server:

$ smbclient //servers_ip/testshare -U samba_username

The above command attempts to connect to a Samba share named [testshare] on the Samba server via its IP address with the username we set up earlier. If successful, it provides a command-line interface (CLI) to manage files and directories within the share.

Let’s list all files or directories in the Samba CLI:

smb: \> ls
  .                                   D        0  Thu Mar 28 01:21:28 2024
  ..                                  D        0  Thu Mar 28 01:43:40 2024
  file1                               N        0  Thu Mar 28 01:21:28 2024
  file2                               N        0  Thu Mar 28 01:21:28 2024

		40581564 blocks of size 1024. 38768520 blocks available
smb: \>

As seen above, the files we created in the previous steps are visible in the Samba share.

3. Setting up a File Server With NFS

NFS, short for Network File System, is a distributed file system protocol used to access files and directories on a remote server. The NFS server runs on the machine with the storage we want to share. On the other hand, we use the mount command with the NFS server’s IP address to access the share on the client machine.

3.1. Configure NFS Share

First, we install nfs-kernel-server, nfs-common, and rpcbind on the server machine as the prerequisites for NFS:

$ sudo apt install nfs-kernel-server nfs-common rpcbind

Next, we create an NFS share directory with the path /var/nfs/public:

$ sudo mkdir -p /var/nfs/public

Then, we grant all permissions to everyone:

$ sudo chmod 777 /var/nfs/public/

However, sharing this directory with the client machine requires defining an export rule in the /etc/exports file:

$ sudo echo /var/nfs/public client_machine_ip(rw,sync,no_subtree_check) >> /etc/exports

This export rule allows the client machine with the specified IP address to read and modify files within the share and prioritize data consistency over performance (due to sync).

To verify the changes, let’s reboot the server and then confirm their implementation:

$ sudo reboot
$ showmount -e
Export list for server_username:
/var/nfs/public client_machine_ip

The output confirms that the export rule has been successfully created.

3.2. Configure NFS Client Mount

The client machine, identified by its IP address, mounts the file system provided by the NFS server.

We begin by creating a mount point named nfs-public and granting it permissions:

$ mkdir /mnt/nfs-public
$ sudo chmod 777 /mnt/nfs-public

Next, we install the prerequisites needed for the client machine to access the NFS server:

$ sudo apt install rpcbind nfs-common

These packages enable the client machine to connect to the NFS server.

3.3. Mount NFS Share on Client

Now we can mount the NFS share:

$ sudo mount server_machine_ip:/var/nfs/public /mnt/nfs-public/

However, the client machine unmounts the mount point during a reboot. To make it permanent, let’s add the mount to /etc/fstab:

$ sudo echo '#NFS server
server_machine_ip:/var/nfs/public /mnt/nfs-public nfs rw 0 0' >> /etc/fstab

Thus, we enable automatic mounting of the NFS share at boot time.

3.4. Access Share

Once it’s mounted, we can access files and directories within the NFS share using the mount point directory. We can execute commands like cd, ls, and cp to interact with shared files.

For example, we can create a directory named testdir in the mount point:

$ cd /mnt/nfs-public
$ mkdir testdir

At this point, testdir should be reflected in the NFS share directory on the server machine. Let’s confirm that on the server machine:

$ cd /var/nfs/public
$ ls
testdir

As seen above, the created directory is also available in the NFS share.

4. Conclusion

In this article, we learned how to set up a simple file server using Samba and NFS. We explored how to configure Samba and NFS for sharing files across networks.

By understanding these tools and instructions, we can establish secure file sharing between machines and streamline collaboration, backups, and more.

Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.