Linux

关注公众号 jb51net

关闭
首页 > 网站技巧 > 服务器 > Linux > Linux搭建NFS实现文件共享

Linux搭建NFS服务器实现Linux文件共享

作者：知远漫谈

本文详细介绍了在Linux环境下搭建NFS（Network File System）服务器的过程,包括安装配置、权限设置、安全加固、客户端挂载、性能优化及故障排查等内容,需要的朋友可以参考下

引言

在现代分布式系统架构中，文件共享是基础且关键的一环。无论是微服务间的数据交换、多节点日志聚合，还是跨主机的配置同步，都需要一种稳定、高效、可扩展的文件共享机制。NFS（Network File System）作为 Unix/Linux 系统中最经典和广泛使用的网络文件系统协议，历经数十年发展依然活跃于生产环境，其简洁性、兼容性和高性能使其成为企业级部署的首选方案之一。

本文将带你从零开始，在 Linux 环境下搭建完整的 NFS 服务器，并通过 Java 编写的客户端程序演示如何在应用程序中访问共享目录，实现跨主机文件读写。我们还将深入探讨安全配置、性能调优、故障排查等实用技巧，让你不仅“会搭”，更能“用好”。

什么是 NFS？

NFS 是由 Sun Microsystems 在 1984 年开发的一种分布式文件系统协议，允许用户像访问本地磁盘一样访问远程主机上的文件。它基于 RPC（Remote Procedure Call）机制，支持 TCP/UDP 传输，默认使用 TCP 协议以确保可靠性。

NFS 的核心优势：

实验环境准备

为了便于演示，我们假设有两台 Linux 主机：

建议使用虚拟机或云服务器进行实验，避免影响生产环境。

所有操作均需 root 权限，请提前准备好 sudo 或直接切换为 root 用户。

第一步：安装 NFS 服务端组件

在 Server 端执行以下命令安装所需软件包：

# Ubuntu/Debian
sudo apt update
sudo apt install nfs-kernel-server rpcbind

# CentOS/RHEL/Fedora
sudo dnf install nfs-utils rpcbind

启动并设置开机自启：

sudo systemctl enable rpcbind nfs-server
sudo systemctl start rpcbind nfs-server

检查服务状态：

sudo systemctl status nfs-server

你应该看到类似输出：

● nfs-server.service - NFS server and services
     Loaded: loaded (/lib/systemd/system/nfs-server.service; enabled; vendor preset: enabled)
     Active: active (exited) since Mon 2024-06-03 10:22:15 CST; 2min ago

第二步：创建共享目录并设置权限

选择一个目录作为共享根目录，例如 /srv/nfs/shared：

sudo mkdir -p /srv/nfs/shared
sudo chown nobody:nogroup /srv/nfs/shared  # Ubuntu 默认使用 nobody 用户
sudo chmod 777 /srv/nfs/shared             # 开放读写权限（生产环境请按需收紧）

注意：nobody 和 nogroup 是默认的匿名用户组，用于映射远程客户端未匹配的 UID/GID。你也可以指定特定用户如 www-data 或自定义用户。

第三步：配置 exports 文件

编辑 /etc/exports 文件，定义哪些目录可以被哪些客户端访问：

sudo nano /etc/exports

添加如下内容：

/srv/nfs/shared 192.168.1.101(rw,sync,no_subtree_check,no_root_squash)

参数详解：

参数说明
rw允许读写（read-write）
sync同步写入，确保数据一致性（牺牲部分性能）
no_subtree_check关闭子树检查，提升性能，适用于整个目录共享
no_root_squash允许客户端 root 用户保留 root 权限（⚠️ 生产慎用！）

安全提示：no_root_squash 会让远程 root 用户拥有服务器端 root 权限，存在严重安全隐患。建议生产环境使用 root_squash（默认），或明确指定 UID 映射。

如果你希望允许多个客户端访问，可以这样写：

/srv/nfs/shared 192.168.1.0/24(rw,sync,no_subtree_check,root_squash)

保存退出后，重新加载配置：

sudo exportfs -ra

验证导出是否成功：

sudo exportfs -v

输出应包含：

/srv/nfs/shared    192.168.1.101(rw,sync,wdelay,hide,no_subtree_check,sec=sys,no_root_squash)

第四步：开放防火墙端口

NFS 使用多个端口，包括：

Ubuntu (ufw):

sudo ufw allow from 192.168.1.101 to any port nfs
sudo ufw allow from 192.168.1.101 to any port 111
sudo ufw allow from 192.168.1.101 to any port 2049

CentOS (firewalld):

sudo firewall-cmd --permanent --add-service=nfs
sudo firewall-cmd --permanent --add-service=rpc-bind
sudo firewall-cmd --permanent --add-service=mountd
sudo firewall-cmd --reload

重启防火墙后建议再次确认服务状态：

sudo systemctl restart nfs-server

第五步：客户端挂载共享目录

切换到 Client 端（192.168.1.101），安装 NFS 客户端工具：

# Ubuntu/Debian
sudo apt install nfs-common

# CentOS/RHEL
sudo dnf install nfs-utils

创建本地挂载点：

sudo mkdir -p /mnt/nfs-shared

手动挂载：

sudo mount -t nfs 192.168.1.100:/srv/nfs/shared /mnt/nfs-shared

验证挂载：

df -h | grep nfs

输出类似：

192.168.1.100:/srv/nfs/shared   20G  5.2G   14G  28% /mnt/nfs-shared

测试读写：

echo "Hello from client!" > /mnt/nfs-shared/test.txt
cat /mnt/nfs-shared/test.txt

如果看到输出，恭喜你，NFS 已成功搭建！

设置开机自动挂载

编辑 /etc/fstab：

sudo nano /etc/fstab

添加一行：

192.168.1.100:/srv/nfs/shared  /mnt/nfs-shared  nfs  defaults,timeo=600,retrans=2,_netdev  0  0

参数说明：

保存后测试：

sudo umount /mnt/nfs-shared
sudo mount -a

无报错即配置成功。

 性能与稳定性测试

你可以使用 dd 命令测试写入速度：

dd if=/dev/zero of=/mnt/nfs-shared/testfile bs=1M count=100 conv=fdatasync

或使用 fio 进行更专业的 I/O 基准测试：

sudo apt install fio
fio --name=randwrite --ioengine=sync --iodepth=1 --rw=randwrite --bs=4k --size=100M --numjobs=1 --directory=/mnt/nfs-shared --runtime=60 --time_based --end_fsync=1

安全加固建议

虽然 NFS 方便，但默认配置并不安全。以下是几条加固建议：

1. 限制访问 IP

在 /etc/exports 中明确指定客户端 IP 或网段，避免 * 通配符。

2. 使用 Kerberos 认证（NFSv4+）

NFSv4 支持 GSSAPI/Kerberos 安全认证，适合企业环境。配置较复杂，但安全性极高。

3. 启用 root_squash

除非必要，不要使用 no_root_squash。默认 root_squash 会将远程 root 映射为 nobody，防止提权攻击。

4. 使用固定端口 + 防火墙白名单

默认 NFS 使用动态端口，不利于防火墙管理。可通过配置固定端口解决：

编辑 /etc/default/nfs-kernel-server（Ubuntu）或 /etc/sysconfig/nfs（CentOS）：

# Ubuntu 示例
RPCMOUNTDOPTS="--manage-gids --port 32767"
STATDOPTS="--port 32765 --outgoing-port 32766"

然后在防火墙中只开放这些端口。

NFS 架构流程图（mermaid）

渲染错误: Mermaid 渲染失败: Lexical error on line 4. Unrecognized text. ...-> D[/srv/nfs/shared] A -->|Read/Wri -----------------------^

上图展示了 NFS 客户端如何通过 RPC 与服务端通信，最终访问共享目录的完整流程。Java 应用通过标准文件 API 间接操作 NFS 挂载点，无需感知底层协议。

第六步：Java 客户端访问 NFS 共享目录

既然 NFS 挂载后如同本地目录，那么 Java 程序可以直接使用 java.nio.file 或 java.io.File 进行操作，无需任何特殊库！

下面是一个完整的 Java 示例程序，演示如何：

  1. 写入文件到 NFS 目录
  2. 读取并校验内容
  3. 监控目录变化
  4. 异常处理与日志记录

Java 代码示例：NFSFileOperator.java

import java.io.*;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 * 🐄 Java NFS 文件操作示例
 * 适用于挂载后的 NFS 共享目录
 */
public class NFSFileOperator {
    private final Path nfsPath;
    private final ScheduledExecutorService scheduler;
    public NFSFileOperator(String nfsMountPoint) {
        this.nfsPath = Paths.get(nfsMountPoint);
        this.scheduler = Executors.newScheduledThreadPool(1);
        // 校验路径是否存在
        if (!Files.exists(nfsPath)) {
            throw new IllegalArgumentException("NFS 挂载点不存在: " + nfsMountPoint);
        }
        if (!Files.isWritable(nfsPath)) {
            throw new IllegalArgumentException("NFS 挂载点不可写: " + nfsMountPoint);
        }
        System.out.println("✅ NFS 挂载点已验证: " + nfsPath);
    }
    /**
     * 写入文本文件
     */
    public void writeTextFile(String filename, String content) throws IOException {
        Path filePath = nfsPath.resolve(filename);
        Files.write(filePath, content.getBytes("UTF-8"));
        System.out.println("📝 文件写入成功: " + filePath);
    }
    /**
     * 读取文本文件
     */
    public String readTextFile(String filename) throws IOException {
        Path filePath = nfsPath.resolve(filename);
        if (!Files.exists(filePath)) {
            throw new FileNotFoundException("文件不存在: " + filePath);
        }
        byte[] bytes = Files.readAllBytes(filePath);
        String content = new String(bytes, "UTF-8");
        System.out.println("📖 文件读取成功: " + filePath);
        return content;
    }
    /**
     * 获取文件信息
     */
    public void printFileInfo(String filename) throws IOException {
        Path filePath = nfsPath.resolve(filename);
        BasicFileAttributes attrs = Files.readAttributes(filePath, BasicFileAttributes.class);
        System.out.println("📄 文件信息:");
        System.out.println("   大小: " + attrs.size() + " 字节");
        System.out.println("   创建时间: " + attrs.creationTime());
        System.out.println("   最后修改: " + attrs.lastModifiedTime());
        System.out.println("   是否为目录: " + attrs.isDirectory());
    }
    /**
     * 监控目录变化（每5秒扫描一次）
     */
    public void startDirectoryMonitor() {
        Runnable monitorTask = () -> {
            try {
                System.out.println("🔍 [" + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_TIME) + "] 扫描目录: " + nfsPath);
                Files.list(nfsPath).forEach(file -> {
                    try {
                        BasicFileAttributes attr = Files.readAttributes(file, BasicFileAttributes.class);
                        System.out.println("   " + file.getFileName() + " (" + attr.size() + " bytes)");
                    } catch (IOException e) {
                        System.err.println("❌ 读取文件属性失败: " + file);
                    }
                });
            } catch (IOException e) {
                System.err.println("❌ 目录扫描失败: " + e.getMessage());
            }
        };
        scheduler.scheduleAtFixedRate(monitorTask, 0, 5, TimeUnit.SECONDS);
        System.out.println("⏱️  目录监控已启动，每5秒刷新一次...");
    }
    /**
     * 停止监控
     */
    public void stopDirectoryMonitor() {
        scheduler.shutdown();
        System.out.println("⏹️  目录监控已停止");
    }
    /**
     * 清理测试文件
     */
    public void cleanupTestFiles() throws IOException {
        Files.list(nfsPath)
             .filter(path -> path.getFileName().toString().startsWith("test_"))
             .forEach(path -> {
                 try {
                     Files.delete(path);
                     System.out.println("🗑️  删除测试文件: " + path);
                 } catch (IOException e) {
                     System.err.println("❌ 删除失败: " + path + " - " + e.getMessage());
                 }
             });
    }
    public static void main(String[] args) {
        // 假设 NFS 挂载在 /mnt/nfs-shared
        String MOUNT_POINT = "/mnt/nfs-shared";
        try {
            NFSFileOperator nfs = new NFSFileOperator(MOUNT_POINT);
            // 测试写入
            String testFilename = "test_" + System.currentTimeMillis() + ".txt";
            nfs.writeTextFile(testFilename, "Hello from Java! 🎉\n当前时间: " + LocalDateTime.now());
            // 测试读取
            String content = nfs.readTextFile(testFilename);
            System.out.println("📄 读取内容:\n" + content);
            // 打印文件信息
            nfs.printFileInfo(testFilename);
            // 启动监控（后台线程）
            nfs.startDirectoryMonitor();
            // 等待15秒
            Thread.sleep(15000);
            // 停止监控
            nfs.stopDirectoryMonitor();
            // 清理测试文件
            nfs.cleanupTestFiles();
            System.out.println("✅ 所有测试完成！");
        } catch (Exception e) {
            System.err.println("❌ 程序执行异常: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

编译与运行 Java 程序

确保你的系统已安装 JDK：

javac --version
java --version

编译：

javac NFSFileOperator.java

运行（确保 NFS 已挂载）：

java NFSFileOperator

预期输出：

✅ NFS 挂载点已验证: /mnt/nfs-shared
📝 文件写入成功: /mnt/nfs-shared/test_1717401234567.txt
📖 文件读取成功: /mnt/nfs-shared/test_1717401234567.txt
📄 文件信息:
   大小: 68 字节
   创建时间: 2024-06-03T10:30:45Z
   最后修改: 2024-06-03T10:30:45Z
   是否为目录: false
⏱️  目录监控已启动，每5秒刷新一次...
🔍 [10:30:45] 扫描目录: /mnt/nfs-shared
   test_1717401234567.txt (68 bytes)
🔍 [10:30:50] 扫描目录: /mnt/nfs-shared
   test_1717401234567.txt (68 bytes)
⏹️  目录监控已停止
🗑️  删除测试文件: /mnt/nfs-shared/test_1717401234567.txt
✅ 所有测试完成！

高级功能：Java NIO WatchService 监控变更

除了定时轮询，你还可以使用 WatchService 实现事件驱动的目录监控：

import java.nio.file.*;
public class NFSWatchServiceExample {
    public static void watchDirectory(Path dir) throws IOException {
        WatchService watcher = FileSystems.getDefault().newWatchService();
        dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE,
                                StandardWatchEventKinds.ENTRY_DELETE,
                                StandardWatchEventKinds.ENTRY_MODIFY);
        System.out.println("👀 开始监听目录变更: " + dir);
        while (true) {
            WatchKey key;
            try {
                key = watcher.take(); // 阻塞等待事件
            } catch (InterruptedException e) {
                return;
            }
            for (WatchEvent<?> event : key.pollEvents()) {
                WatchEvent.Kind<?> kind = event.kind();
                Path fileName = (Path) event.context();
                System.out.println("🔔 事件: " + kind.name() + " - " + fileName);
            }
            boolean valid = key.reset();
            if (!valid) break;
        }
    }
    public static void main(String[] args) throws IOException {
        Path nfsDir = Paths.get("/mnt/nfs-shared");
        watchDirectory(nfsDir);
    }
}

注意：NFS 上的 WatchService 可能不如本地文件系统灵敏，尤其在跨网络延迟较高时。建议结合心跳检测或定时扫描作为补充。

故障排查指南

即使配置正确，NFS 仍可能因网络、权限、服务状态等问题导致挂载失败。以下是常见错误及解决方案：

错误1：mount.nfs: Connection timed out

错误2：mount.nfs: access denied by server

错误3：Permission denied写入失败

错误4：Stale file handle

通常发生在服务端重启或目录被删除后。解决方法：

sudo umount -l /mnt/nfs-shared  # lazy unmount
sudo mount -a                  # 重新挂载

性能优化技巧

1. 使用 async 而非 sync（仅当数据可容忍丢失时）

/srv/nfs/shared client(rw,async,no_subtree_check)

async 允许服务器先响应再写盘，显著提升吞吐量。

2. 调整 rsize/wsize

挂载时指定更大的读写块大小：

sudo mount -t nfs -o rsize=32768,wsize=32768 192.168.1.100:/srv/nfs/shared /mnt/nfs-shared

3. 启用 noatime

避免每次读取都更新访问时间：

sudo mount -t nfs -o noatime 192.168.1.100:/srv/nfs/shared /mnt/nfs-shared

4. 使用 NFSv4（推荐）

NFSv4 更安全、更高效，支持状态化操作和复合请求。挂载时指定版本：

sudo mount -t nfs -o vers=4.2,proto=tcp 192.168.1.100:/srv/nfs/shared /mnt/nfs-shared

与其他技术集成

与 Docker 集成

在 docker run 中直接挂载 NFS 目录：

docker run -v /mnt/nfs-shared:/app/data my-app-image

或在 docker-compose.yml 中：

services:
  app:
    image: my-app
    volumes:
      - /mnt/nfs-shared:/data

与 Kubernetes 集成

使用 PersistentVolume + PersistentVolumeClaim：

apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs-pv
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteMany
  nfs:
    server: 192.168.1.100
    path: "/srv/nfs/shared"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nfs-pvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 10Gi

跨平台注意事项

虽然 NFS 主要用于 Linux/Unix，但 Windows 也可通过以下方式接入：

MacOS 原生支持 NFS，挂载命令：

sudo mount -t nfs 192.168.1.100:/srv/nfs/shared /Volumes/nfs

实际应用场景举例

场景1：多节点日志集中存储

多个应用服务器将日志写入同一 NFS 目录，由中央日志分析器统一采集。

场景2：Web 集群共享静态资源

图片、CSS、JS 等静态文件放在 NFS，所有 Web 节点挂载相同路径，实现内容同步。

场景3：CI/CD 构建产物共享

Jenkins 构建生成的 .jar、.war 文件存入 NFS，供部署脚本或其他流水线步骤使用。

场景4：机器学习数据集共享

训练数据集放在 NFS，多个 GPU 节点并行读取，避免重复下载。

替代方案对比

方案优点缺点适用场景
NFS成熟、稳定、原生支持权限模型较弱、无加密Linux 内部文件共享
Samba支持 Windows、权限精细配置复杂、性能略低混合操作系统环境
GlusterFS分布式、高可用、横向扩展架构复杂、运维成本高大规模分布式存储
CephFS弹性扩展、对象+块+文件一体学习曲线陡峭云原生存储、PB级需求
SSHFS简单、安全（走 SSH）性能较差、不支持锁临时挂载、调试用途

对于大多数中小型项目，NFS 仍是性价比最高的选择。

开发者须知：Java 应用最佳实践

路径硬编码 → 配置化

不要写死 /mnt/nfs-shared，改用环境变量或配置文件：

String nfsPath = System.getenv("NFS_MOUNT_POINT");
if (nfsPath == null) nfsPath = "/mnt/nfs-shared";

增加重试机制

NFS 可能因网络抖动暂时不可用，建议封装重试逻辑：

public void writeWithRetry(String content, int maxRetries) {
    for (int i = 0; i <= maxRetries; i++) {
        try {
            writeTextFile("data.txt", content);
            return;
        } catch (IOException e) {
            if (i == maxRetries) throw e;
            try { Thread.sleep(1000); } catch (InterruptedException ie) {}
        }
    }
}

监控磁盘空间

定期检查剩余空间，避免写满导致服务崩溃：

FileStore store = Files.getFileStore(nfsPath);
long free = store.getUsableSpace();
if (free < 100 * 1024 * 1024) { // 小于100MB
    logger.warn("NFS 空间不足: " + free + " bytes remaining");
}

异常隔离

NFS I/O 异常不应导致整个应用崩溃，建议使用熔断器模式（如 Resilience4j）。

总结

通过本文，你已经掌握了：

✅ 在 Linux 上从零搭建 NFS 服务器
✅ 配置安全、高性能的共享策略
✅ 客户端挂载与自动挂载技巧
✅ 使用 Java 程序无缝操作 NFS 文件
✅ 故障排查与性能优化实战经验
✅ 与其他技术栈（Docker/K8s）集成方法

NFS 虽然“古老”，但其设计哲学——简单、可靠、透明——至今仍极具价值。在云原生时代，它依然是连接容器、虚拟机、物理机之间文件共享的桥梁。

无论你是 DevOps 工程师、后端开发者，还是系统架构师，掌握 NFS 都将为你在分布式系统领域打下坚实基础。

常见问题 FAQ

Q1: NFS 支持文件锁吗？

A: 支持，但需要启用 nfslock 服务。在客户端和服务端都要启动：

sudo systemctl enable nfs-lock
sudo systemctl start nfs-lock

Java 中可通过 FileChannel.tryLock() 使用。

Q2: 如何查看当前 NFS 连接和统计信息？

A: 使用 nfsstat 和 showmount：

nfsstat -c    # 客户端统计
nfsstat -s    # 服务端统计
showmount -e 192.168.1.100  # 查看导出列表

Q3: NFS 断网后会怎样？

A: 正在进行的 I/O 会阻塞，直到超时或网络恢复。建议应用层设置合理超时，并实现优雅降级。

Q4: 可以加密 NFS 传输吗？

A: 原生 NFS 不支持加密。可通过以下方式实现：

下一步学习建议

以上就是Linux搭建NFS服务器实现Linux文件共享的详细内容，更多关于Linux搭建NFS实现文件共享的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:
阅读全文