Skip to main content

Kubernetes / CSI

Integrating MooseFS with Kubernetes

In today’s cloud-native world, Kubernetes (K8s) has become the de facto standard for container orchestration. However, managing persistent storage across dynamic containers remains one of Kubernetes’ more complex challenges. This is where MooseFS, a fault-tolerant, scalable distributed file system, shines.

In this guide, we'll explore how to integrate MooseFS with Kubernetes, allowing your containers to access reliable, scalable storage without losing data when pods move, restart, or scale.

Why Use MooseFS with Kubernetes?​

MooseFS offers several advantages that align well with Kubernetes' dynamic environment:

  • Fault Tolerance: Automatic replication of data ensures availability.
  • Scalability: Easily expand storage by adding more chunkservers.
  • Simplicity: Minimal configuration needed to run large, resilient storage clusters.
  • Cost Efficiency: Runs on commodity hardware.

By integrating MooseFS with Kubernetes, you can provide persistent storage volumes for your pods without relying on expensive cloud storage solutions or heavyweight SAN/NAS setups.

Architecture Overview​

Here’s how the integration typically looks:

  • MooseFS Master Server (mfsmaster) manages metadata and coordinates file operations.
  • MooseFS Chunkservers (mfschunkserver) store actual file data across multiple nodes.
  • MooseFS Clients (mfsmount or FUSE clients) mount the filesystem inside pods or on Kubernetes nodes.
  • PersistentVolume (PV) / PersistentVolumeClaim (PVC) in Kubernetes manage storage access for applications.

Step-by-Step Integration Guide​

1. Set Up Your MooseFS Cluster​

First, install and configure your MooseFS components:

  • Deploy the Master Server.
  • Set up Chunkservers across multiple nodes.
  • Configure replication goals for your data.

Tip: Ensure your Kubernetes nodes have network access to your MooseFS cluster.

2. Install the MooseFS Client on Kubernetes Nodes​

Since pods need access to MooseFS volumes, your Kubernetes worker nodes must have the MooseFS client installed.

Example (on Ubuntu):

sudo apt update
sudo apt install moosefs-client

Repeat this step for all worker nodes.

3. Mount MooseFS on Worker Nodes (Optional)​

You can mount a MooseFS volume directly onto Kubernetes nodes using mfsmount, and then create Kubernetes hostPath volumes pointing to that mount.

Example:

sudo mkdir /mnt/mfs
sudo mfsmount /mnt/mfs -H mfsmaster.example.com

Note: Ensure mfsmount is set to remount automatically after node reboots (/etc/fstab).

4. Expose MooseFS Storage to Kubernetes​

Now you have a few options:

Option 1: Use hostPath​

The simplest way is to expose the mounted MooseFS folder via a hostPath volume.

Example PersistentVolume:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mfs-pv
spec:
  capacity:
    storage: 500Gi
  accessModes:
    - ReadWriteMany
  hostPath:
    path: /mnt/mfs

Example PersistentVolumeClaim:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mfs-pvc
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 100Gi

Pros:

  • Simple to implement.

Cons:

  • Tied to specific nodes unless using a global mount.
  • Requires mounting on all nodes.

Option 2: Create a MooseFS CSI Driver (Advanced)​

A more cloud-native approach is to develop (or adapt) a Container Storage Interface (CSI) driver for MooseFS. CSI drivers allow dynamic provisioning, attaching, and mounting of storage.

As of now, a MooseFS-specific CSI driver isn’t officially available — but it's possible to create one based on existing FUSE-based CSI templates (like csi-driver-nfs).

Steps:

  • Create a CSI driver that mounts MooseFS via FUSE inside pods.
  • Deploy it in your Kubernetes cluster.
  • Use StorageClasses and PVCs to dynamically provision storage.

If you're interested, I can help outline a CSI driver architecture for MooseFS.

5. Deploy Applications Using MooseFS Volumes​

Once your PersistentVolume and PersistentVolumeClaim are set up, you can mount storage in your pods.

Example Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mfs-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: mfs-app
  template:
    metadata:
      labels:
        app: mfs-app
    spec:
      containers:
      - name: app
        image: your-app-image
        volumeMounts:
        - mountPath: /data
          name: mfs-storage
      volumes:
      - name: mfs-storage
        persistentVolumeClaim:
          claimName: mfs-pvc

Your application now reads and writes data to MooseFS seamlessly!

Best Practices for Production​

  • Replication Goals: Configure appropriate replication for your MooseFS files to avoid data loss.
  • Network Monitoring: Monitor network latency and throughput, since MooseFS performance depends heavily on network speed.
  • Node Affinity: Use node selectors or affinity rules to ensure your pods run on nodes with mounted MooseFS volumes if you use hostPath.
  • Security: Secure MooseFS network communications with SSL/TLS if needed.
  • Backups: Even though MooseFS is resilient, implement regular backup strategies.

Conclusion​

Integrating MooseFS with Kubernetes can be a powerful, cost-effective way to provide persistent, scalable storage for your containerized applications. Whether you take the quick hostPath approach or invest in a full CSI driver for dynamic provisioning, MooseFS gives you the flexibility and resilience needed for serious production workloads.

With careful planning and a bit of setup, you can bring the best of distributed storage and container orchestration together — enabling faster development, more reliable apps, and lower costs.