Network file sharing between Linux systems forms the backbone of efficient data management in modern IT environments. Whether you are managing a home lab, administering enterprise servers, or simply transferring files between personal machines, understanding how to configure file sharing across Linux distributions like Ubuntu and Arch Linux is an essential skill. This guide walks you through the most effective methods for establishing secure, reliable file sharing between Linux systems, complete with step-by-step instructions and command-line examples.

Understanding Linux File Sharing Technologies

Before diving into configuration, it is important to understand the primary technologies available for Linux-to-Linux file sharing. Each approach offers distinct advantages depending on your specific use case, security requirements, and performance needs.

The Network File System, or NFS, represents the most native and efficient solution for Linux-to-Linux sharing. Developed originally by Sun Microsystems, NFS has been a staple of Unix and Linux networking for decades. It operates on a client-server model where the server exports directories that clients mount as if they were local filesystems. NFS performs exceptionally well within trusted networks due to its lightweight protocol and minimal overhead.

Samba, despite its origins as a compatibility layer for Windows file sharing, also serves Linux-to-Linux environments effectively. When you need to share files across heterogeneous environments or maintain compatibility with Windows systems that might join your network later, Samba provides a robust solution. Modern Samba configurations offer strong security features and excellent performance.

Secure Shell-based solutions, including SCP and SFTP, provide encrypted file transfer capabilities without requiring complex server configuration. These methods prove ideal for one-time transfers, automated scripts, or situations where mounting remote filesystems seems excessive.

Setting Up NFS File Sharing Between Linux Systems

NFS offers the most straightforward path to seamless file sharing between Linux machines. The following sections detail how to configure both Ubuntu and Arch Linux systems as NFS servers and clients.

Configuring the NFS Server

Begin by installing the necessary NFS server software on the machine that will host the shared directories. On Ubuntu, execute the following commands with root privileges to install the NFS kernel server and related utilities. The installation process automatically creates the necessary system groups and user mappings that NFS requires for operation.

sudo apt update
sudo apt install nfs-kernel-server

On Arch Linux, the process requires installing the nfs-utils package, which provides both client and server functionality. Arch follows a minimal installation philosophy, so you may need to enable and start theRPC bind service before configuring NFS.

sudo pacman -Syu
sudo pacman -S nfs-utils
sudo systemctl enable --now rpcbind.service

With the software installed, you must now define which directories the server will share and which clients may access them. This configuration lives in the /etc/exports file, where each line specifies a directory path, client access parameters, and export options. Consider a configuration that shares the /data directory with two specific machines on your local network, configuring appropriate permissions and squash settings to prevent privilege escalation.

sudo mkdir -p /data/shared
sudo chown nobody:nogroup /data/shared
sudo chmod 755 /data/shared

Edit the exports file using your preferred text editor, adding a line that specifies the shared directory and client machines. The following example grants read-write access to two specific IP addresses while using the rw and sync options to ensure data integrity.

sudo nano /etc/exports

Add the following line to /etc/exports, adjusting the IP addresses to match your network configuration:

/data/shared 192.168.1.10(rw,sync,no_subtree_check) 192.168.1.11(rw,sync,no_subtree_check)

After saving the configuration, export the shared directories and restart the NFS server to apply the changes. The exportfs command with the -a flag processes all entries in /etc/exports, while the -r option resynchronizes the current export table.

sudo exportfs -a
sudo systemctl restart nfs-kernel-server  # Ubuntu
sudo systemctl restart nfs-server.service  # Arch Linux

Configuring the NFS Client

On the machine that will access the shared directories, install the NFS client utilities and create a mount point directory. The client side requires far less configuration than the server, as most settings are determined by the server's export options.

Ubuntu

sudo apt install nfs-common

Arch Linux

sudo pacman -S nfs-utils

Create the mount point directory and mount the remote filesystem. The mount command connects to the NFS server and makes the remote directory accessible through the local mount point. For permanent mounting, add an entry to the /etc/fstab file, which instructs the system to establish the connection automatically during boot.

sudo mkdir -p /mnt/nfs/shared
sudo mount 192.168.1.100:/data/shared /mnt/nfs/shared

For permanent mounting, add this line to /etc/fstab:

192.168.1.100:/data/shared /mnt/nfs/shared nfs defaults,timeo=900,retrans=5,_netdev 0 0

Implementing Samba for Linux-to-Linux File Sharing

While NFS excels in pure Linux environments, Samba provides additional flexibility and compatibility benefits. Modern Samba versions offer excellent performance and robust security features that make them suitable for Linux-only networks as well.

Installing and Configuring Samba on Ubuntu

Begin by installing the Samba package along with its associated utilities. The installation process on Ubuntu automatically configures basic services and creates the necessary system users, though significant configuration remains necessary.

sudo apt update
sudo apt install samba samba-common-bin

Create a dedicated directory for sharing and set appropriate ownership permissions. It is good practice to create a specific system user for Samba access, separating Samba authentication from regular system login credentials.

sudo mkdir -p /samba/shared
sudo groupadd sambashare
sudo useradd -s /s/bin/false -G sambashare sambauser
sudo chown -R sambauser:sambashare /samba/shared
sudo chmod 0770 /samba/shared

Configure Samba by editing the /etc/samba/smb.conf file. This configuration file uses a simple ini-style format where square brackets define share names and the remaining lines specify parameters for each share. The following configuration creates a share named shared with valid user access and appropriate permission settings.

sudo nano /etc/samba/smb.conf

Add the following configuration section to the end of the file:

[shared]
comment = Shared Directory
path = /samba/shared
read only = no
browsable = yes
valid users = sambauser
create mask = 0660
directory mask = 0770

Set a password for the Samba user, which must exist as a system user but uses a separate password database for Samba authentication. This dual-password system provides an additional layer of security by preventing regular system login through Samba access.

sudo smbpasswd -a sambauser

Restart the Samba services to load the new configuration. Ubuntu uses the smbd and nmbd daemons for CIFS/SMB functionality, with nmbd handling NetBIOS name resolution.

sudo systemctl restart smbd nmbd
sudo systemctl enable smbd nmbd

Installing and Configuring Samba on Arch Linux

The Arch Linux installation follows a similar pattern, though package management and service handling differ slightly. Arch typically requires more manual configuration but offers greater flexibility.

sudo pacman -Syu
sudo pacman -S samba

Create the required directories and user accounts using the same principles as the Ubuntu configuration. Arch Linux does not enable services by default, so explicit enablement steps are necessary.

sudo mkdir -p /samba/shared
sudo groupadd sambashare
sudo useradd -s /s/bin/false -G sambashare sambauser
sudo chown -R sambauser:sambashare /samba/shared
sudo chmod 0770 /samba/shared

Configure Samba identically to the Ubuntu setup by editing /etc/samba/smb.conf. The configuration file format remains consistent across distributions. Create a basic configuration file if the default one does not suit your needs.

sudo nano /etc/samba/smb.conf

Add the same share configuration section described in the Ubuntu instructions. Then, set the Samba password and enable the required services.

sudo smbpasswd -a sambauser
sudo systemctl enable --now smbd nmbd

Accessing Samba Shares from Linux Clients

From any Linux machine on the network, you can access Samba shares using the smbclient utility or by mounting the share directly. Installing cifs-utils enables direct mounting behavior similar to NFS mounts.

Install client utilities

sudo apt install cifs-utils  #### Ubuntu
sudo pacman -S cifs-utils    #### Arch Linux

Create mount point and mount the share

sudo mkdir -p /mnt/samba
sudo mount -t cifs //192.168.1.100/shared /mnt/samba -o user=sambauser,password=your_password

Securing Your Linux File Sharing Environment

Security must remain paramount when configuring network file sharing. Both NFS and Samba offer various security mechanisms that you should understand and implement appropriately.

For NFS, the /etc/exports file controls client access at the network level. Never export directories to the entire internet or untrusted networks. The rw and ro options control read-write access, while root_squash and all_squash options map privileged user requests to unprivileged accounts, preventing clients from accessing files as root. Consider using specific IP addresses or network ranges rather than hostnames, which can be spoofed in certain circumstances.

Secure export example

/data/shared 192.168.1.0/24(rw,sync,root_squash,no_subtree_check)

Samba security operates primarily through user authentication and share-level permissions. The valid users parameter restricts access to specific accounts, while read only and writable parameters control access mode. For enhanced security, consider implementing Samba with TLS encryption, which requires additional certificates but protects credentials and data from network sniffing.

Both solutions require appropriate firewall configuration. Ubuntu uses UFW by default, while Arch often relies on iptables or nftables. Allow only the necessary ports for your configuration.

UFW for Ubuntu

sudo ufw allow from 192.168.1.0/24 to any port 2049  # NFS
sudo ufw allow from 192.168.1.0/24 to any port 445   # Samba

Arch Linux using firewalld

sudo firewall-cmd --permanent --add-service=nfs
sudo firewall-cmd --permanent --add-service=samba
sudo firewall-cmd --reload

Testing and Troubleshooting Your Configuration

After configuration, thorough testing ensures everything functions correctly before relying on the setup for production use. Begin by verifying that the server correctly advertises its shares using the appropriate discovery commands.

For NFS, use the showmount utility to query the server's exported directories. From the client machine, execute the following command against your NFS server's IP address to display available shares.

showmount -e 192.168.1.100

For Samba, the smbclient utility provides an interactive browsing capability that tests both connectivity and authentication. This command logs in to the specified share using the configured username, prompting for a password that should match your Samba password.

smbclient -U sambauser //192.168.1.100/shared

Common issues typically involve permission mismatches, firewall blocking, or service status problems. Verify that all required services are running using systemctl status commands, and check logs in /var/log/ directories when authentication or mounting failures occur. Ensure that both server and client time settings are synchronized, as authentication failures sometimes result from time drift between machines.

Conclusion

Establishing file sharing between Linux systems need not be intimidating, regardless of whether you work with Ubuntu, Arch Linux, or a mixture of distributions. NFS provides the most efficient solution for Linux-native environments, while Samba offers broader compatibility and familiar configuration patterns. Both technologies, when properly secured, provide robust foundations for networked file sharing that rival or exceed Windows file sharing capabilities.

Begin with NFS for pure Linux environments where simplicity and performance are priorities. Consider Samba when Windows compatibility might become necessary or when you prefer its authentication model. Implement firewall rules and appropriate export options to maintain security throughout your configuration. With the steps outlined in this guide, you now possess the knowledge to configure reliable, secure file sharing across your Linux infrastructure.