K8S #02 : PV/PVC et GlusterFS

P’tit stockage distribué 😎

Toujours dans la continuité du précédent article sur mon cluster Kubernetes, on va voir aujourd’hui comment installer GlusterFS pour avoir un sockage distribué, et tester le montage de volume avec apache !

Et ça, ça va être sympatoche.

Ah oui, petit disclaimer: il se peut que j’utilise storage ou stockage dépendant des phrases, vous voilà prévenus même si globalement on s’en fiche un peu~

II) Il était une fois GlusterFS, et le stockage distribué

J’avais déjà un peu bossé avec GlusterFS à l’époque, y’a de ça quatre ans environ… alors ça date un peu, mais le soft est toujours très utilisé et très souvent mis à jour ! C’est du solide.

Histoire de présenter une Infra un poil redondante, je suis donc parti sur ce choix de storage, en lieu et place de NFS ou même de Ceph. Voilà le topo :

• glusterfs-01.tips4tech.local, en 192.168.0.51/24, avec 50Gb~ de disque ;
• glusterfs-02.tips4tech.local, en 192.168.0.52/24, avec 50Gb~ de disque ;
• glusterfs-03.tips4tech.local, en 192.168.0.53/24, avec 50Gb~ de disque ;

On remercie encore une fois Packer/Terraform pour le gain de temps !

L’idée, c’est de créer un dossier sur chacun de nos nœuds, qu’on va appeler par exemple /data/glusterfs/, et dont le contenu va être répliqué en temps réel sur chacun d’entre eux.

Si, sur glusterfs-01, je fais un touch /data/glusterfs/SuperFichier, ce fameux SuperFichier sera répliqué sur les deux autres serveurs !

Du coup, si l’un d’eux vient à tomber, les deux autres sont toujours disponibles, d’où le fameux stockage distribué.

Et au niveau de nos nœuds (mais cette fois je parle des nodes Kubernetes), on montera ce fameux volume en renseignant nos différents hôtes. Comme ça, si l’un vient à tomber, c’est transparent même jusqu’au montage. Ensuite, pour la partie pure K8S, car là je faisais allusion au niveau OS, on créera un PersistentVolume qui est une sorte de couche d’abstraction pour nos points de montage.

Et enfiiiiin, nos services/pods utiliseront un objet de type PersistentVolumeClaim pour accéder à ce fameux volume 🙂

Pour plus de clarté, j’ai réalisé rapidos un schéma sur draw.io, car j’adore ça et je sais que vous aussi :

On a donc notre cluster GlusterFS, avec notre folder. On va monter ce folder sur chacun de nos nœuds K8S, puis ensuite on créer un PersistentVolume dans Kubernetes, et ensuite nos différents pods ou services vont pouvoir utiliser un PersistentVolumeClaim pour finalement accéder à notre précieux storage.

P’tet que ça a l’air compliqué/pas très clair, mais je vous rassure, c’est plutôt facile à mettre en œuvre ! 😋

III) Mise en place du cluster

Assez bavardé, allons-y directement !

On installe le soft’ et on l’active au démarrage :

sudo apt update && sudo apt install -y glusterfs-server
sudo systemctl enable --now glusterd

On créer notre fameux dossier, et on donne les droits à glusterFS. A réaliser sur chacun des nœuds :

sudo mkdir -p /data/glusterfs
sudo chown -R gluster:gluster /data/glusterfs

On monte notre cluster :

# Commandes à réaliser sur glusterfs-01
sudo gluster peer probe glusterfs-02
sudo gluster peer probe glusterfs-03

Et on peut ensuite exécuter un petit gluster peer status histoire de voir si tout est en ordre :

C’est tout bon ! On poursuit.

Toujours sur glusterfs-01, on va créer notre volume. Par défaut la nomenclature est gvX, pour gluster_volume_X. Un peu comme avec LVM, on le nom par défaut est souvent vgX.

Bref, ici on créer donc un simple volume nommé sobrement gv0 :

sudo gluster volume create gv0 replica 3 transport tcp \
glusterfs-01:/data/glusterfs \
glusterfs-02:/data/glusterfs \
glusterfs-03:/data/glusterfs

L’argument replica 3 est utilisé car nous avons 3 noeuds, et transport tcp car ce sera le protocole utilisé pour la communication entre eux. GlusterFS propose aussi de l’udp, rdma, ou encore du P2P mais ça ne nous intéresse pas ici 😉

*Side note: si vous avez créer votre volume sur une partition système racine ( / ), vous devrez rajouter l’argument « force » à la fin de la précédente commande.

Ensuite, on peut démarrer notre volume :

sudo gluster volume start gv0

Et réaliser un petit coup de gluster volume info pour vérifier là encore que tout soit OK :

Maintenant passons à notre second cluster, le Kubernetes ! On va s’occuper de la partie purement OS/Système dans un premier temps, et ensuite seulement on gérera K8S.

IV) Montage sur chaque Node K8S

Bien, on se connecte donc en SSH sur nos trois nœuds, et on peut commencer par créer le dossier qui va accueillir notre volume à monter :

sudo mkdir /mnt/glusterfs

Et à partir d’ici, c’est encore plus simple !

On installe le client glusterfs :

sudo apt update && sudo apt install -y glusterfs-client

On monte ensuite manuellement le volume, et on peut y mettre un fichier pour tester la réplication :

sudo mount -t glusterfs glusterfs-01,glusterfs-02,glusterfs-03:/gv0 /mnt/glusterfs

# Depuis master-01
touch /mnt/glusterfs/SuperFichier

It works ! Le fichier est bien répliqué sur nos deux autres noeuds !

La dernière étape est de rajouter notre entrée au fichier fstab, afin que ce volume soit monté au démarrage. A noter aussi que, comme sur le schéma, cette commande indique bien nos trois différents serveurs, afin que si le premier venait à tomber, les deux autres sont là pour assurer l’accès aux datas :

# Rajouter l'entrée dans /etc/fstab

echo -e "# Mount the glusterFS volume\nglusterfs-01,glusterfs-02,glusterfs-03:/gv0 /mnt/glusterfs glusterfs defaults,_netdev 0 0" | sudo tee -a /etc/fstab

Et c’est tout bon ! 😎

Vous avez réussi à mettre en place un cluster GlusterFS avec un stockage distribué, et à monter ce volume sur 3 clients ! Maintenant, passons à la partie K8S…

V) Création du PersistentVolume sur Kubernetes

On touche presque au but ! Il ne nous reste plus qu’à indiquer que ce volume est disponible pour K8S, et ensuite de créer un service qui l’utilisera pour vérifier que tout roule.

Pour ce faire, on se créer un folder storage et on vient y mettre notre fichier YAML décrivant notre PV :

apiVersion: v1
kind: PersistentVolume
metadata:
  name: glusterfs-volume
spec:
  capacity:
    storage: 40Gi
  volumeMode: Filesystem
  persistentVolumeReclaimPolicy: Retain
  accessModes:
    - ReadWriteMany
  hostPath:
    path: /mnt/glusterfs/
    type: Directory

Rien de très compliqué ici, on renseigne la capacité (j’ai mis 40Gb~), et on renseigne le point de montage.

Ensuite, kubectl apply -f vous connaissez la chanson !

Aussi simple que ça… et pour finir, créons rapidement un petit serveur web Apache qui va store son folder web sur ce volume. On éditera la page index.html, puis on verra en temps réel si les changements sont bien apportés !

apiVersion: v1
kind: Namespace
metadata:
  name: apache-testing
---
apiVersion: v1
kind: PersistentVolume
metadata:
  name: glusterfs-volume-apache # On créer un PV nommé pour notre service
spec:
  capacity:
    storage: 40Gi
  volumeMode: Filesystem
  persistentVolumeReclaimPolicy: Retain
  accessModes:
    - ReadWriteMany
  hostPath:
    path: /mnt/glusterfs/apache/
    type: Directory
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: apache-pvc # On créer un PVC qui va s'y rattacher
  namespace: apache-testing
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 2Gi
  volumeName: glusterfs-volume-apache
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: apache-deployment
  namespace: apache-testing
spec:
  replicas: 1
  selector:
    matchLabels:
      app: apache
  template:
    metadata:
      labels:
        app: apache
    spec:
      containers:
        - name: apache
          image: httpd:latest
          ports:
            - containerPort: 80
          volumeMounts:
            - name: apache-storage
              mountPath: /usr/local/apache2/htdocs/ # On renseigne le dossier à monter
          resources:
            limits:
              memory: "512Mi"
              cpu: "0.5"
            requests:
              memory: "256Mi"
              cpu: "0.25"
      volumes:
        - name: apache-storage
          persistentVolumeClaim:
            claimName: apache-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: apache-service
  namespace: apache-testing
spec:
  ports:
    - port: 80
      targetPort: 80
  selector:
    app: apache
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: apache-ingress
  namespace: apache-testing
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
    - host: apache.tips4tech.local
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: apache-service
                port:
                  number: 80

Alors ici quelques petites précisions :

• J’ai créé un sous-dossier dans /mnt/glusterfs, appelé /mnt/glusterfs/apache. Ce dossier est donc automatiquement créé sur tous mes nodes K8S car c’est un stockage distribué.
• Le dossier web n’est pas, comme classiquement avec Apache, /var/www/html, mais bien /usr/local/apache2/htdocs/… ça m’aura fait perdre une petite heure car j’ai pas fait gaffe… 🙄 ;

Bref, on peut ensuite démarrer le tout via kubectl apply -f.

And it works !

On a donc réussi à mettre en place notre PersistentVolume via un dossier monté par glusterFS, et à créer un service apache utilisant un PersistentVolumeClaim pour monter son folder web ! 🥳

Petite note cependant, si jamais l’on supprime notre namespace, il faudra aussi penser à supprimer le PV… sinon, lors de la prochaine ré-application de notre manifeste, on obtiendra une erreur. Dans tout les cas, les données ne sont pas perdues car nous avons utilisé Retain comme persistentVolumeReclaimPolicy.

Visiblement, il y a moyen d’automatiser tout ça/faire plus propre… vais continuer de creuser de mon côté !

VI) Conclusion

La partie storage dans Kubernetes, surtout avec une infra OnPrem peut vite être laborieuse j’ai l’impression… je voulais rajouter la partie Harbor dans cet article mais d’une part léger manque de temps, et seconde chose j’ai découvert Longhorn, qui visiblement permet de faciliter la gestion des Volumes…

Bref, j’ai encore pas mal de choses à apprendre ! 😁

Je vais donc continuer tout ça et une fois que je maîtriserai le tout je continuerai cette série d’articles. Au passage, mon nouveau « labo » est en bonne voie ! On y parlera pfSense, NAS, et VLANs ! Mais il faudra patienter encore quelques semaines…

Sur ce, bonne journée/soirée à vous ! Tchô !