CubeFS: High-Performance Storage for Cloud-Native Apps

Through achieving graduation status from the Cloud Native Computing Foundation, CubeFS reaches an important breakthrough as a distributed file system created by community input. CubeFS’s graduation status demonstrates its achieved technical sophistication while establishing its reliable history of managing production workloads on a large scale. CubeFS provides low-latency file lookups and high throughput storage with strong protection through separate handling of metadata and data storage while remaining suited for numerous types of computing workloads. 

The inherent compatibility between CubeFS’s cloud-native design and Kubernetes achieves full automation of deployments together with rolling upgrades as well as scalable node adaptation to meet increasing data needs. CubeFS establishes itself as a trustworthy high-performance solution for container-based organizations wanting to upgrade their storage systems because of its dedicated open-source community support and adherence to the CNCF quality standards.

Introduction to CubeFS

CubeFS functions as a distributed file system that developers worldwide can access under an open-source license. The distribution of file operations occurs between MetaNodes, which handle metadata management tasks, and DataNodes manage data storage tasks overseen by the Master Node, which coordinates cluster activities. Authored structure achieves quick file searches and maintains high data processing speed. When data nodes fail, replication mechanisms safeguard them, resulting in highly reliable support for essential large-scale applications.

Why Deploy on Kubernetes

Kubernetes offers automated container orchestration, scaling, and a consistent way to deploy microservices. By running CubeFS on Kubernetes:

• You can quickly add or remove MetaNodes and DataNodes to match storage needs.
• You benefit from Kubernetes features like rolling updates, health checks, and autoscaling.
• You can integrate with the Container Storage Interface (CSI) for dynamic provisioning of volumes.

End-to-End Deployment Examples

Below are YAML manifests that illustrate a straightforward deployment of CubeFS on Kubernetes. They define PersistentVolumeClaims (PVCs) for each component, plus Deployments or StatefulSets for the Master, MetaNodes, and DataNodes. Finally, they show how to mount and use the file system from a sample pod.

Master Setup

Master PVC

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: cubefs-master-pvc
  labels:
    app: cubefs-master
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
  storageClassName: 

Master Service

apiVersion: v1
kind: Service
metadata:
  name: cubefs-master-svc
  labels:
    app: cubefs-master
spec:
  selector:
    app: cubefs-master
  ports:
    - name: master-port
      port: 17010
      targetPort: 17010
  type: ClusterIP

Master Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: cubefs-master-deploy
  labels:
    app: cubefs-master
spec:
  replicas: 1
  selector:
    matchLabels:
      app: cubefs-master
  template:
    metadata:
      labels:
        app: cubefs-master
    spec:
      containers:
      - name: cubefs-master
        image: cubefs/cubefs:latest
        ports:
        - containerPort: 17010
        volumeMounts:
        - name: master-data
          mountPath: /var/lib/cubefs/master
        env:
        - name: MASTER_ADDR
          value: "0.0.0.0:17010"
        - name: LOG_LEVEL
          value: "info"
      volumes:
      - name: master-data
        persistentVolumeClaim:
          claimName: cubefs-master-pvc

MetaNode Setup

MetaNode PVC

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: cubefs-meta-pvc
  labels:
    app: cubefs-meta
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: 

MetaNode StatefulSet

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: cubefs-meta-sts
  labels:
    app: cubefs-meta
spec:
  serviceName: "cubefs-meta-sts"
  replicas: 2
  selector:
    matchLabels:
      app: cubefs-meta
  template:
    metadata:
      labels:
        app: cubefs-meta
    spec:
      containers:
      - name: cubefs-meta
        image: cubefs/cubefs:latest
        ports:
        - containerPort: 17011
        volumeMounts:
        - name: meta-data
          mountPath: /var/lib/cubefs/metanode
        env:
        - name: MASTER_ENDPOINT
          value: "cubefs-master-svc:17010"
        - name: METANODE_PORT
          value: "17011"
        - name: LOG_LEVEL
          value: "info"
      volumes:
      - name: meta-data
        persistentVolumeClaim:
          claimName: cubefs-meta-pvc

DataNode Setup

DataNode PVC

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: cubefs-data-pvc
  labels:
    app: cubefs-data
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 100Gi
  storageClassName: 

DataNode StatefulSet

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: cubefs-data-sts
  labels:
    app: cubefs-data
spec:
  serviceName: "cubefs-data-sts"
  replicas: 3
  selector:
    matchLabels:
      app: cubefs-data
  template:
    metadata:
      labels:
        app: cubefs-data
    spec:
      containers:
      - name: cubefs-data
        image: cubefs/cubefs:latest
        ports:
        - containerPort: 17012
        volumeMounts:
        - name: data-chunk
          mountPath: /var/lib/cubefs/datanode
        env:
        - name: MASTER_ENDPOINT
          value: "cubefs-master-svc:17010"
        - name: DATANODE_PORT
          value: "17012"
        - name: LOG_LEVEL
          value: "info"
      volumes:
      - name: data-chunk
        persistentVolumeClaim:
          claimName: cubefs-data-pvc

Consuming CubeFS

With the Master, MetaNodes, and DataNodes running, you can mount CubeFS in your workloads. Below is a simple pod spec that uses a hostPath for demonstration. In practice, you may prefer the CubeFS CSI driver for dynamic volume provisioning.

apiVersion: v1
kind: Pod
metadata:
  name: cubefs-client-pod
spec:
  containers:
  - name: cubefs-client
    image: cubefs/cubefs:latest
    command: ["/bin/sh"]
    args: ["-c", "while true; do sleep 3600; done"]
    securityContext:
      privileged: true
    volumeMounts:
    - name: cubefs-vol
      mountPath: /mnt/cubefs
  volumes:
  - name: cubefs-vol
    hostPath:
      path: /mnt/cubefs-host
      type: DirectoryOrCreate

Inside this pod, you would run:

mount.cubefs -o master=cubefs-master-svc:17010 /mnt/cubefs

Check logs to ensure successful mounting, and test file I/O operations.

Post-Deployment Checks

• Master Logs: kubectl logs cubefs-master-deploy-
• MetaNode Logs: kubectl logs cubefs-meta-sts-0 and kubectl logs cubefs-meta-sts-1
• DataNode Logs: kubectl logs cubefs-data-sts-0, etc.
• I/O Test: Write and read files on /mnt/cubefs to confirm everything is functioning.

Conclusion

Through its CNCF graduation, CubeFS achieves confirmed enterprise-grade status as a cloud-native storage system that withstands demanding data workloads. Organizations gain simple operational storage solutions that improve performance while optimizing resource usage through CubeFS’s scalable architecture and efficient Kubernetes integration, which also provides fault tolerance. CubeFS stands as a dependable choice thanks to features that consistently evolve due to active community backing empowered by CNCF graduation while providing key users support for modern storage solutions that handle any data volume.