docker

How to use Docker with a container-native storage solution like Rook?

Dylan

Dylan

— 3 min read
How to use Docker with a container-native storage solution like Rook?

Hey there, tech enthusiasts! 👋 Today, we're diving into the exciting world of container orchestration and storage, specifically how to use Docker with a container-native storage solution like Rook. Strap in, because we're about to take a deep dive into a world where containers and storage dance together in perfect harmony. 🎉

The Setup: Docker and Rook

Before we get into the nitty-gritty, let's lay down some groundwork. Docker is a platform that allows developers to develop, deploy, and run applications in containers. It's like a magic box that packages your application and its dependencies together, making it easy to move and run anywhere. 📦

Rook, on the other hand, is an open-source project that provides a storage orchestration system for cloud-native environments. It's like a dance partner for your Docker containers, ensuring they have all the storage they need to perform their best. 💾

The Pre-Dance Warm-Up: Prerequisites

To get started, you'll need a few things:

  1. Docker: Make sure Docker is installed and running on your system. You can check by running docker --version.
  2. Kubernetes: Rook operates on Kubernetes, so you'll need a Kubernetes cluster. Minikube is a great way to get started locally.
  3. Rook: You'll need to install Rook on your Kubernetes cluster. You can find the installation guide on the Rook GitHub repository.

The First Step: Deploying Rook

Once you've got your environment set up, it's time to deploy Rook. This involves creating a custom resource definition (CRD) and a Rook operator. Here's a quick rundown:

  1. Create the Rook CRDs:

    kubectl create -f https://raw.githubusercontent.com/rook/rook/master/cluster/examples/kubernetes/crds.yaml

  2. Deploy the Rook Operator:

    kubectl create -f https://raw.githubusercontent.com/rook/rook/master/cluster/examples/kubernetes/rook-operator.yaml

  3. Verify the Operator is Running:

    kubectl get pod -n rook-ceph -o custom-columns=NAME:.metadata.name,STATUS:.status.phase

The Dance Begins: Configuring Storage

Now that Rook is up and running, it's time to configure your storage. Here's how you can create a Rook storage cluster:

  1. Create a Storage Cluster:

    apiVersion: ceph.rook.io/v1
kind: CephCluster
metadata:
  name: rook-ceph
  namespace: rook-ceph
spec:
  dataDirHostPath: /var/lib/rook
  mon:
    count: 3
  storage:
    useAllNodes: true
    useAllDevices: false

    Save this as ceph-cluster.yaml and apply it with kubectl apply -f ceph-cluster.yaml.

  2. Check the Cluster Status:

    kubectl -n rook-ceph get cephcluster

The Tango Continues: Using the Storage with Docker

With Rook managing your storage, you can now create Persistent Volumes (PVs) and Persistent Volume Claims (PVCs) for your Docker containers.

  1. Create a Persistent Volume:

    apiVersion: v1
kind: PersistentVolume
metadata:
  name: my-pv
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: rook-ceph-block
  local:
    path: /mnt/data/block
  nodeAffinity:
    required:
       nodeSelectorTerms:
         - matchExpressions:
             - key: kubernetes.io/hostname
               operator: In
               values:
                 - my-node

    Save this as my-pv.yaml and apply it with kubectl apply -f my-pv.yaml.

  2. Create a Persistent Volume Claim:

    apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  storageClassName: rook-ceph-block
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

    Save this as my-pvc.yaml and apply it with kubectl apply -f my-pvc.yaml.

  3. Deploy a Docker Container with the PVC:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-container
          image: my-image:latest
          volumeMounts:
            - mountPath: /data
              name: my-pv
      volumes:
        - name: my-pv
          persistentVolumeClaim:
            claimName: my-pvc

    Save this as my-app-deployment.yaml and deploy it with kubectl apply -f my-app-deployment.yaml.

The Final Bow: Managing and Expanding

Congratulations! 🎉 You've successfully danced Docker and Rook through a container-native storage solution. But wait, there's more! You can manage and expand your storage as needed:

  • Scale the Storage: Adjust the storage size in your storage class or add more nodes to your cluster.
  • Backup and Restore: Use Rook's backup and restore features to ensure your data is safe.
  • Monitor: Keep an eye on your storage usage and performance with Rook's monitoring tools.

Wrapping Up

And there you have it! You've just learned how to waltz Docker and Rook together in a beautiful container-native storage solution. It's not just about the steps, but also about the rhythm and the harmony between the two. 💖

Remember, the key to a successful dance is practice and patience. So, keep experimenting, and soon you'll be a pro at managing storage for your Docker containers with Rook. Happy coding, and may your storage solutions always be as smooth as a well-choreographed dance! 👨‍💻💃🎶

Read more