NFS-CSI 面试题

Pod → kubelet → CSI Node Driver → mount -t nfs → NFS 服务器 → 存储后端

1. 用户创建 PVC → Provisioner 监听事件
2. Provisioner 调用 CSI CreateVolume 接口
3. CSI Driver 在 NFS 服务器上创建子目录
4. 权限设置、配额配置
5. 返回 Volume 信息（挂载路径）
6. PV 自动创建并与 PVC 绑定

1. Pod 调度到节点 → kubelet 调用 CSI NodePublishVolume
2. Node Driver 执行 mount -t nfs -o options <server>:<path> <target>
3. NFS 挂载完成 → Pod 启动
4. 数据路径：Pod → FUSE/NFS 客户端 → NFS 服务器 → 存储后端

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-csi
provisioner: nfs.csi.k8s.io
parameters:
  server: nfs-server.example.com
  share: /exports
  subDir: ${pvc.namespace}/${pvc.name}
  mountPermissions: "0777"
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
mountOptions:
- hard
- nfsvers=4.1
- noatime

apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs-pv
spec:
  capacity:
    storage: 100Gi
  accessModes:
    - ReadWriteMany
  nfs:
    path: /exports/data
    server: nfs-server.example.com
  persistentVolumeReclaimPolicy: Retain

# 用户只创建 PVC
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nfs-pvc
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: nfs-csi
  resources:
    requests:
      storage: 10Gi

1. 用户修改 PVC spec.resources.requests.storage
2. CSi Resizer 监听 PVC 变更
3. 调用 CSI ControllerExpandVolume 接口
4. CSI Driver 在后端调整配额（quota）或扩展文件系统
5. 更新 PV 的容量字段
6. Pod 内文件系统自动感知新容量（xfs_growfs / resize2fs）

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-csi-expandable
provisioner: nfs.csi.k8s.io
allowVolumeExpansion: true  # 必须启用
parameters:
  server: nfs-server.example.com
  share: /exports

# 1. 创建 VolumeSnapshotClass
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: nfs-snapshot-class
driver: nfs.csi.k8s.io
deletionPolicy: Delete
parameters:
  # 后端特定参数（如 LVM 快照、ZFS 快照等）

# 2. 创建快照
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: nfs-data-snapshot
spec:
  volumeSnapshotClassName: nfs-snapshot-class
  source:
    persistentVolumeClaimName: nfs-pvc

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nfs-restored-pvc
spec:
  storageClassName: nfs-csi
  dataSource:
    name: nfs-data-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  resources:
    requests:
      storage: 10Gi

# CTDB 配置 /etc/ctdb/ctdb.conf
CTDB_RECOVERY_LOCK=/nfs-lock
CTDB_PUBLIC_ADDRESSES=/etc/ctdb/public_addresses
CTDB_NODES=/etc/ctdb/nodes

# /etc/ctdb/public_addresses
192.168.1.100/24 eth0  # 虚拟 IP

EXPORT {
    Export_Id = 1;
    Path = "/exports/data";
    Pseudo = "/exports/data";
    Access_Type = RW;
    FSAL {
        Name = VFS;
    }
}

主 NFS 服务器故障 → CTDB 检测心跳超时
  → 将虚拟 IP 迁移到备用 NFS 服务器
  → 备用服务器接管 NFS 服务
  → NFS 客户端重连（30-60 秒超时）
  → 客户端恢复访问

NFS 协议设计允许多个客户端共享同一导出路径
  → 内核 NFS 客户端维护缓存一致性
  → 文件锁（flock/fcntl）在客户端间协调
  → 服务端没有连接数限制（理论上）

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-csi-rwx
provisioner: nfs.csi.k8s.io
parameters:
  server: nfs-server.example.com
  share: /exports
  mountPermissions: "0777"
allowVolumeExpansion: true
mountOptions:
- hard
- nfsvers=4.1
- noatime

apiVersion: apps/v1
kind: Deployment
metadata:
  name: shared-app
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: app
        volumeMounts:
        - mountPath: /shared-data
          name: shared-storage
      volumes:
      - name: shared-storage
        persistentVolumeClaim:
          claimName: nfs-shared-pvc

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-csi-custom
provisioner: nfs.csi.k8s.io
parameters:
  # NFS 服务器地址（必需）
  server: nfs-server.example.com
  
  # NFS 导出路径前缀（必需）
  share: /exports
  
  # 子目录命名规则（可选）
  subDir: "${pvc.namespace}/${pvc.name}"
  # 或固定目录
  # subDir: "k8s-volumes"
  
  # 挂载权限（可选）
  mountPermissions: "0777"
  
  # NFS 协议版本（可选）
  nfsvers: "4.1"
  
  # 网络和传输
  protocol: "tcp"
  
  # 后端存储（可选，区分不同 NFS 后端）
  # storage: "fast-hdd"
  
allowVolumeExpansion: true
reclaimPolicy: Delete
volumeBindingMode: Immediate
mountOptions:
- hard
- nfsvers=4.1
- noatime
- rsize=1048576
- wsize=1048576

mountOptions:
- nfsvers=4.1       # NFS 协议版本（3/4.0/4.1/4.2）
- proto=tcp          # 传输协议（tcp/udp）
- port=2049          # NFS 端口
- mountport=20048    # mountd 端口（NFS v3）

mountOptions:
- hard               # 硬挂载（服务器恢复后自动重连，推荐）
- soft               # 软挂载（超时后返回错误）
- intr               # 硬挂载时可中断（允许 Ctrl+C）
- timeo=600          # 超时时间（1/10 秒单位）
- retrans=5          # 重试次数
- retry=2            # 挂载重试次数

mountOptions:
- noatime            # 不更新访问时间（减少元数据写入）
- nodiratime         # 不更新目录访问时间
- rsize=1048576      # 读缓冲区大小（1MB）
- wsize=1048576      # 写缓冲区大小（1MB）
- acregmin=60        # 文件属性缓存最短时间（秒）
- acregmax=120       # 文件属性缓存最长时间
- acdirmin=60        # 目录属性缓存最短时间
- acdirmax=120       # 目录属性缓存最长时间
- actimeo=120        # 统一设置属性缓存时间

mountOptions:
- sec=sys            # 本机 UID/GID 认证（默认）
- sec=krb5           # Kerberos 5 认证
- sec=krb5i          # Kerberos 5 + 完整性
- sec=krb5p          # Kerberos 5 + 完整性 + 加密
- noexec             # 禁止执行二进制
- nosuid             # 禁止 suid
- nodev              # 禁止设备节点

# NFS 服务器上为每个 PV 创建独立用户
useradd -M -u 10001 pvc-user-1
setquota -u 10001 10G 12G 0 0 /exports

# 独立 mount point
mount -o loop /exports/pv-vol /mnt/pv-vol

# 项目配额（xfs projid）
xfs_quota -x -c "project -s -p /exports/pvc-xx pvc-xx" /dev/vg/lv
xfs_quota -x -c "limit -p bsoft=10G bhard=12G pvc-xx" /dev/vg/lv

apiVersion: storage.k8s.io/v1
kind: StorageClass
parameters:
  server: nfs-server.example.com
  share: /exports
  # 通过自定义后端脚本实现配额
  quotaEnabled: "true"

# 服务器上检查配额使用
repquota -a
xfs_quota -x -c "report -p" /dev/vg/lv

# Pod 内查看
kubectl exec <pod> -- df -h <mount-path>

# ganesha.conf 导出配置
EXPORT {
    Export_Id = 1;
    Path = "/cephfs/k8s-volumes";
    Pseudo = "/k8s-volumes";
    Access_Type = RW;
    Squash = No_Root_Squash;
    Protocols = 4;
    FSAL {
        Name = CEPH;
        user_id = "admin";
    }
}

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-ganesha-csi
provisioner: nfs.csi.k8s.io
parameters:
  server: ganesha-cluster-vip.example.com
  share: /k8s-volumes
  subDir: ${pvc.namespace}/${pvc.name}

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-krb5-csi
provisioner: nfs.csi.k8s.io
parameters:
  server: secure-nfs.example.com
  share: /exports
mountOptions:
- sec=krb5p  # Kerberos 认证 + 加密
- nfsvers=4.2

# 1. 创建 Kerberos 密钥表 Secret
kubectl create secret generic nfs-krb5-secret \
  --from-file=krb5.keytab=/etc/krb5.keytab \
  --from-file=krb5.conf=/etc/krb5.conf

# 2. 将密钥挂载到 CSI Node Driver
kubectl edit daemonset nfs-csi-node
# volumes:
# - name: krb5
#   secret:
#     secretName: nfs-krb5-secret

# StorageClass mountOptions
mountOptions:
# 缓冲区大小（提高大文件吞吐）
- rsize=1048576       # 读缓冲区 1MB
- wsize=1048576       # 写缓冲区 1MB

# 缓存优化
- noatime             # 关闭访问时间更新
- nodiratime          # 关闭目录访问时间更新
- acregmin=120        # 文件属性缓存 2 分钟
- acregmax=300        # 文件属性缓存最长 5 分钟
- acdirmin=120        # 目录属性缓存
- acdirmax=300

# 并发优化
- nocto               # 关闭关闭到打开一致性检查（谨慎）
- hard                # 硬挂载（重试优于失败）

# 节点内核参数
# /etc/sysctl.d/nfs-performance.conf
net.core.rmem_default = 262144
net.core.rmem_max = 16777216
net.core.wmem_default = 262144
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.ipv4.tcp_congestion_control = bbr  # BBR 拥塞控制

# NFS 服务器 /etc/nfs.conf
[nfsd]
threads=64           # NFS 内核线程数
grace-time=90        # 优雅恢复时间
lease-time=90        # 租约时间（NFS v4）

# /etc/exports
/exports *(rw,sync,no_wdelay,no_subtree_check,fsid=0)

mountOptions:
- nfsvers=3
- lock              # 启用文件锁（NLM）
- nolock            # 禁用文件锁（数据不安全）

mountOptions:
- nfsvers=4.1       # NFS v4 自动包含锁功能
- noacl             # 禁用 ACL（提高锁性能）
- nostatfs          # 禁用 statfs 缓存

NFS v3 锁服务器（rpc.statd）故障
  → 锁信息丢失 → 客户端锁可能失效
  → NFS v4 锁（基于租约）：
    → 租约超时（默认 90 秒）后锁自动释放
    → 客户端需重新获取锁

# 1. 检查 CSI Driver Pod 状态
kubectl get pods -n kube-system | grep nfs-csi
kubectl logs -n kube-system daemonset/nfs-csi-node

# 2. 检查 CSIDriver 资源
kubectl get csidrivers
kubectl describe csidriver nfs.csi.k8s.io

# 3. 检查 PVC/PV 状态
kubectl describe pvc <pvc-name>
kubectl describe pv <pv-name>

# 检查 NFS 服务器可达
kubectl exec <pod> -- ping -c 3 <nfs-server>

# 检查 NFS 导出
showmount -e <nfs-server>

# rpcinfo 检查 NFS 服务（NFS v3）
rpcinfo -p <nfs-server>

# 测试 NFS 挂载
mount -t nfs -o nfsvers=4.1 <nfs-server>:/exports /mnt/test

# 检查 Pod 内挂载
kubectl exec <pod> -- mount | grep nfs
kubectl exec <pod> -- df -h | grep nfs

# 检查挂载权限
kubectl exec <pod> -- ls -la <mount-path>
kubectl exec <pod> -- touch <mount-path>/test-file

# 文件系统检查
kubectl exec <pod> -- stat -f <mount-path>

# Velero 安装时启用 CSI 插件
velero install \
  --plugins velero/velero-plugin-for-csi \
  --features EnableCSI

# Velero Backup 自动调用 CSI Snapshot
velero backup create nfs-backup \
  --include-namespaces production \
  --snapshot-volumes \
  --wait

# 安装 Velero 文件系统备份插件
velero install \
  --use-volume-snapshots=false \
  --plugins velero/velero-plugin-for-csi \
  --features EnableCSI \
  --default-volumes-to-fs-backup

# 通过 Annotation 指定备份
apiVersion: v1
kind: Pod
metadata:
  annotations:
    backup.velero.io/backup-volumes: data-volume

# 使用标准文件工具备份 NFS 数据
# Velero 可以使用 restic 从 Pod 内备份
velero backup create nfs-app-backup \
  --include-namespaces my-app \
  --default-volumes-to-restic

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-csi
provisioner: nfs.csi.k8s.io
reclaimPolicy: Delete  # 默认

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-csi-retain
provisioner: nfs.csi.k8s.io
reclaimPolicy: Retain

# PVC 删除后 PV 处于 Released 状态
kubectl get pv

# 删除 PV（数据保留在 NFS 服务器）
kubectl delete pv <pv-name>

# 手动清理 NFS 服务器上的目录
rm -rf /exports/<pvc-namespace>/<pvc-name>

mountOptions:
- hard
- intr               # 允许 NFS 操作被信号中断

mountOptions:
- soft
- timeo=600          # 超时时间（1/10 秒）
- retrans=3          # 重试次数

NFS v4 协议层不区分 hard/soft（选项仅作用于内核客户端）
  - hard 是默认且推荐的行为
  - NFS v4 的 lease 机制（默认 90 秒超时）替代 soft 的 timeo 功能
  - 实际行为在两个版本间保持一致

apiVersion: v1
kind: Pod
metadata:
  name: subpath-pod
spec:
  containers:
  - name: app1
    volumeMounts:
    - name: data
      mountPath: /var/log/app1
      subPath: app1-logs
  - name: app2
    volumeMounts:
    - name: data
      mountPath: /var/log/app2
      subPath: app2-logs
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: nfs-shared-pvc

spec:
  initContainers:
  - name: init-volume
    image: busybox
    command:
    - mkdir
    - -p
    - /data/app1-logs
    volumeMounts:
    - name: data
      mountPath: /data

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: web
  replicas: 3
  template:
    spec:
      containers:
      - name: nginx
        image: nginx
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes:
      - ReadWriteMany
      storageClassName: nfs-csi
      resources:
        requests:
          storage: 10Gi

StatefulSet: web, Replicas: 3
→ web-0 → PVC: www-web-0 → PV: pvc-xxx-0
→ web-1 → PVC: www-web-1 → PV: pvc-xxx-1
→ web-2 → PVC: www-web-2 → PV: pvc-xxx-2

/exports/
  └── web/
      ├── www-web-0/       # web-0 的卷数据
      ├── www-web-1/       # web-1 的卷数据
      └── www-web-2/       # web-2 的卷数据

mountOptions:
- nfsvers=4.1
# 启用 pNFS
- minorversion=1

mountOptions:
- hard               # 硬挂载，服务器恢复后自动重试
- soft               # 软挂载，超时后返回错误
- intr               # 允许中断 NFS 操作（仅 hard 模式）
- timeo=600          # 初始超时（1/10 秒，默认 600=60 秒）
- retrans=5          # 最大重试次数（soft 模式）
- retry=2            # 挂载重试次数

mountOptions:
- rsize=1048576      # 读缓冲区（bytes，默认 1MB）
- wsize=1048576      # 写缓冲区（bytes，默认 1MB）
- noatime            # 不更新文件访问时间
- nodiratime         # 不更新目录访问时间
- acregmin=60        # 文件属性最小缓存时间
- acregmax=120       # 文件属性最大缓存时间
- acdirmin=60        # 目录属性最小缓存时间
- acdirmax=120       # 目录属性最大缓存时间
- nocto              # 关闭关闭到打开一致性检查
- noac               # 关闭数据缓存（强一致性）

mountOptions:
- sec=sys            # AUTH_SYS（默认）
- sec=krb5           # Kerberos 5
- sec=krb5i          # Kerberos + 完整性
- sec=krb5p          # Kerberos + 加密

mountOptions:
- nfsvers=4.1        # 协议版本
- proto=tcp          # 传输协议
- port=2049          # NFS 端口
- mountport=20048    # mountd 端口（v3）
- fsc                # 本地文件系统缓存

apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs-static-pv
  annotations:
    pv.kubernetes.io/provisioned-by: nfs.csi.k8s.io
spec:
  capacity:
    storage: 100Gi
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  csi:
    driver: nfs.csi.k8s.io
    volumeHandle: nfs-static-volume-001
    volumeAttributes:
      server: nfs-server.example.com
      share: /exports/static/data
      mountPermissions: "0777"

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nfs-static-claim
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 100Gi
  volumeName: nfs-static-pv  # 指定绑定到现有 PV

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: netapp-nfs
provisioner: nfs.csi.k8s.io
parameters:
  server: netapp-nfs.company.com
  share: /vol/k8s_pool
  subDir: ${pvc.namespace}/${pvc.name}
mountOptions:
- nfsvers=4.1
- hard
- noatime

# AWS EFS CSI Driver（虽然独立，但基于 NFS）
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: efs-csi
provisioner: efs.csi.aws.com
parameters:
  provisioningMode: efs-ap
  fileSystemId: fs-xxxx
  directoryPerms: "700"
  basePath: "/k8s-volumes"

graph TD
    A["Pod 内进程 UID（如 1000）"] --> B["Linux NFS 客户端将 UID 发送到服务器"]
    B --> C["服务器依据 UID 检查文件权限"]
    C --> D["root (UID 0) 受 root_squash 影响"]

apiVersion: storage.k8s.io/v1
kind: StorageClass
parameters:
  mountPermissions: "0777"  # 设置挂载点权限

# NFS 服务器 /etc/exports
/exports *(rw,sync,root_squash)  # root 映射为 nobody
/exports *(rw,sync,no_root_squash) # root 保留权限

# Init Container 修复权限
spec:
  initContainers:
  - name: volume-permissions
    image: busybox
    command:
    - chown
    - -R
    - "1000:1000"
    - /data
    volumeMounts:
    - name: data
      mountPath: /data
  securityContext:
    runAsUser: 1000
    fsGroup: 1000

# StorageClass 配置
parameters:
  server: nfs-cluster.company.com  # DNS A 记录指向多个 IP

parameters:
  server: nfs-lb.company.com  # 负载均衡器 VIP

graph LR
    A["NFS-1 + NFS-2 + NFS-3"] -->|"CTDB 集群"| B["NFS 虚拟 IP：192.168.1.100<br/>故障自动切换"]
    B --> C["所有节点提供完全相同的 NFS 导出"]

mountOptions:
- nfsvers=4.1
# 多 IP 多路径自动负载均衡

# NFS 服务器 exports 配置
/exports *(rw,sync,no_wdelay)

# 强一致性（关闭缓存）
mountOptions:
- noac               # 关闭属性缓存
- sync               # 同步写入模式

# 高性能（弱一致性）
mountOptions:
- acregmin=60        # 属性缓存 60 秒
- noatime            # 不更新访问时间

**数据校验：**
- NFS 协议不提供数据校验功能
- 应用层校验（checksum）是数据完整性保障的推荐方式
- NFS-CSI 不介入数据校验

# NFS 服务器 exports 安全配置
/exports *(rw,sync,no_subtree_check,no_wdelay,fsid=0)

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-csi-prod
provisioner: nfs.csi.k8s.io
parameters:
  server: nfs-cluster-vip.company.com
  share: /exports/k8s
  subDir: ${pvc.namespace}/${pvc.name}
  mountPermissions: "0770"
allowVolumeExpansion: true
reclaimPolicy: Retain
volumeBindingMode: WaitForFirstConsumer
mountOptions:
- nfsvers=4.1
- hard
- intr
- noatime
- rsize=1048576
- wsize=1048576

NFS 服务器模板：
  nfsd_threads_util     # NFS 线程利用率
  nfs_rpc_ops           # RPC 操作频率
  nfs_read_throughput   # 读吞吐量
  nfs_write_throughput  # 写吞吐量
  nfs_client_count      # 连接客户端数
  network_bandwidth     # 网络带宽使用

同区域 NFS 延迟：0.5-2ms
跨区域 NFS 延迟：
  同城（< 50km）：3-10ms
  跨省：20-50ms
  跨国：100-300ms+

NFS 每次文件操作都需要 RTT（往返时间）：
  读 1MB 文件（rsize=1MB）→ 1 次 RTT
  写 1MB 文件（wsize=1MB）→ 1 次 RTT
  目录遍历 1000 文件 → 1000 次 RTT

mountOptions:
- rsize=1048576  # 1MB
- wsize=1048576  # 1MB

mountOptions:
- acregmin=600       # 10 分钟
- acregmax=1200      # 20 分钟
- acdirmin=600
- acdirmax=1200

mountOptions:
- nfsvers=4.1
- nocto              # 关闭关闭到打开一致性（谨慎）