Aller au contenu principal

Utiliser un PVC comme stockage persistant (S3)

Rôle​

Cette fonctionnalité vous permet d'utiliser un bucket S3 comme volume persistant dans votre cluster Kubernetes, accessible depuis un ou plusieurs pods simultanément — y compris sur des nœuds différents.

Concrètement, cela signifie que vous pouvez monter un bucket S3 comme un PersistentVolumeClaim (PVC) de type ReadWriteMany (RWX), exactement comme vous le feriez avec n'importe quel autre volume Kubernetes. Techniquement, c'est GeeseFs (un client FUSE haute performance) qui monte le bucket S3 comme un système de fichiers POSIX sur chaque nœud concerné.

Cas d'usage typiques :

  • Partage de fichiers statiques entre plusieurs réplicas d'une application
  • Stockage de médias (images, vidéos) accessibles depuis plusieurs pods
  • Données partagées entre différents services d'une même application

Activation​

Depuis la console Ziosting, rendez-vous sur l'onglet Paramètres de votre service Kubernetes. Vous y trouverez un panneau "Stockage persistant RWX" qui vous permet d'activer ou de désactiver cette option.

info

L'activation de cette option déclenche le déploiement du driver CSI GeeseFs sur votre cluster. Attendez quelques minutes que les pods se déploient avant de commencer à créer des ressources.

Désactivation​

Pour désactiver cette option, vous devez au préalable supprimer du cluster toutes les ressources Kubernetes associées. Sans cela, la désactivation peut être demandée depuis la console mais ne sera pas effective.

Ordre de suppression recommandé :

  1. Les pods / workloads utilisant les PVC concernés (pour libérer les montages actifs)
  2. Les PersistentVolumeClaim créés avec les StorageClass GeeseFs
  3. Toutes les StorageClass créées pour ce stockage RWX — obligatoire
  4. Les Secret contenant les credentials S3 dans kube-system (recommandé)
attention

La présence d'au moins une StorageClass utilisant le provisioner ru.yandex.s3.csi bloque la désactivation effective du driver. La suppression des StorageClass est donc obligatoire avant de désactiver l'option sur la console.

Vérification : Pour confirmer que la désactivation est bien effective, attendez quelques minutes après avoir demandé la désactivation côté console, puis vérifiez l'absence du DaemonSet csi-s3 dans le namespace geesefs :

kubectl get daemonset csi-s3 -n geesefs

Si la commande retourne Error from server (NotFound), l'option est bien désactivée.

Utilisation​

Une fois l'option activée, suivez les étapes ci-dessous pour utiliser un bucket S3 comme PVC dans vos pods.

Pré-requis​

Avant de commencer, assurez-vous de disposer des informations suivantes concernant votre bucket S3 :

  • Nom du bucket : le nom du bucket S3 à monter
  • Endpoint : l'URL du service S3 (ex: https://s3.fr-par.scw.cloud pour Scaleway, https://s3.eu-central-1.amazonaws.com pour AWS)
  • Clef d'accès (accessKeyID)
  • Secret d'accès (secretAccessKey)

Étape 1 — Créer le Secret​

Déployez un objet Secret dans le namespace kube-system contenant vos credentials S3. Adaptez les valeurs entre < > avec vos propres informations.

apiVersion: v1
kind: Secret
metadata:
  namespace: kube-system
  name: <nom-donné-au-Secret>
stringData:
  accessKeyID: <votre-clef-s3>
  secretAccessKey: <votre-secret-s3>
  # Pour AWS : "https://s3.<region>.amazonaws.com", ex: https://s3.eu-central-1.amazonaws.com
  endpoint: <ex. https://s3.fr-par.scw.cloud pour Scaleway>
  # Pour AWS, renseignez également la région :
  #region: ""
kubectl apply -f secret-s3.yaml

Étape 2 — Créer la StorageClass​

Déployez un objet StorageClass qui référence votre secret et votre bucket S3. Adaptez les valeurs entre < >.

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: <nom-donné-à-la-SC>
provisioner: ru.yandex.s3.csi
parameters:
  mounter: geesefs
  # Limite recommandée du cache mémoire (en Mo)
  options: "--memory-limit 1000"
  bucket: <nom-de-votre-bucket>
  csi.storage.k8s.io/provisioner-secret-name: <nom-donné-au-Secret>
  csi.storage.k8s.io/provisioner-secret-namespace: kube-system
  csi.storage.k8s.io/controller-publish-secret-name: <nom-donné-au-Secret>
  csi.storage.k8s.io/controller-publish-secret-namespace: kube-system
  csi.storage.k8s.io/node-stage-secret-name: <nom-donné-au-Secret>
  csi.storage.k8s.io/node-stage-secret-namespace: kube-system
  csi.storage.k8s.io/node-publish-secret-name: <nom-donné-au-Secret>
  csi.storage.k8s.io/node-publish-secret-namespace: kube-system
kubectl apply -f storageclass-s3.yaml

Étape 3 — Créer le PersistentVolumeClaim​

Déployez un PersistentVolumeClaim utilisant la StorageClass créée à l'étape précédente. Adaptez les valeurs entre < >.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: <nom-donné-au-PVC>
  namespace: default
spec:
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 5Gi
  storageClassName: <nom-donné-à-la-SC>
kubectl apply -f pvc-s3.yaml
remarque

La taille indiquée dans storage (ici 5Gi) est indicative pour Kubernetes. Elle ne limite pas réellement l'espace utilisé sur le bucket S3 — c'est la capacité de votre bucket qui fait foi.

Étape 4 — Utiliser le PVC dans un pod​

Une fois le PVC créé, vous pouvez le monter dans un pod comme n'importe quel autre volume Kubernetes. Voici un exemple avec un pod nginx :

apiVersion: v1
kind: Pod
metadata:
  name: pod-de-test-nginx
  namespace: default
spec:
  containers:
   - name: test
     image: nginx
     volumeMounts:
       - mountPath: /usr/share/nginx/html/s3
         name: webroot
  volumes:
   - name: webroot
     persistentVolumeClaim:
       claimName: <nom-donné-au-PVC>
       readOnly: false
kubectl apply -f pod-nginx.yaml

Le répertoire /usr/share/nginx/html/s3 dans le conteneur sera alors synchronisé avec le contenu de votre bucket S3.

Bonnes pratiques​

  • Cache mémoire : Limitez le cache mémoire via l'option --memory-limit dans la StorageClass pour éviter une consommation excessive de RAM sur les nœuds (valeur recommandée : 1000 pour 1 Go).
  • Workloads adaptés : GeeseFs est optimisé pour les accès séquentiels (lecture/écriture de fichiers). Évitez de l'utiliser pour des bases de données ou des applications nécessitant des accès aléatoires intensifs.