Utiliser un pilote CSI (Container Storage interface) pour Azure Files dans Azure Kubernetes Service (AKS)

Le pilote CSI (Container Storage Interface) pour Azure Files est un pilote conforme à la spécification CSI utilisé par Azure Kubernetes Service (AKS) pour gérer le cycle de vie des partages Azure Files. CSI est une norme pour exposer des systèmes de stockage de blocs et de fichiers arbitraires à des charges de travail en conteneur sur Kubernetes.

En adoptant et en utilisant CSI, AKS peut désormais écrire, déployer et itérer les plug-ins pour exposer de nouveaux systèmes de stockage ou améliorer les existants dans Kubernetes. L’utilisation de pilotes CSI dans AKS permet d’éviter de toucher au code Kubernetes de base et d’attendre ses cycles de mise en production.

Pour créer un cluster AKS avec prise en charge des pilotes CSI, consultez Activation des pilotes CSI sur AKS.

Notes

Les pilotes dans l’arborescence font référence aux pilotes de stockage actuels, qui font partie du code Kubernetes principal, par opposition aux nouveaux pilotes CSI, qui sont des plug-ins.

Nouvelles fonctionnalités du pilote CSI Azure Files

En plus des fonctionnalités de pilote d’origine dans l’arborescence, le pilote CSI Azure Files prend en charge les nouvelles fonctionnalités suivantes :

• NFS (Network File System) version 4.1
• Point de terminaison privé
• Création d’un grand montage de partages de fichiers en parallèle.

Utiliser un volume persistant avec Azure Files

Un volume persistant représente un élément de stockage provisionné pour une utilisation dans des pods Kubernetes. Un volume persistant peut être utilisé par un ou plusieurs pods et être provisionné de façon statique ou dynamique. Si plusieurs pods doivent accéder simultanément au même volume de stockage, vous pouvez utiliser Azure Files pour la connexion avec le protocole SMB (Server Message Block) ou NFS. Cet article vous montre comment créer un partage Azure Files de manière dynamique utilisé par plusieurs pods dans un cluster AKS. Pour l’approvisionnement statique, consultez Créer et utiliser manuellement un volume avec un partage Azure Files.

Remarque

Veuillez noter que le pilote CSI de fichiers Azure autorise uniquement le montage de partages de fichiers SMB à l’aide d’une authentification basée sur des clés (NTLM v2), et ne prend donc pas en charge le profil de sécurité maximal des paramètres de partage de fichiers Azure. En revanche, le montage de partages de fichiers NFS ne nécessite pas d’authentification basée sur des clés.

Avec les partages Azure Files, il n’existe aucune limite quant au nombre de partages pouvant être montés sur un nœud.

Pour plus d’informations sur les volumes Kubernetes, consultez Options de stockage pour les applications dans AKS.

Créer dynamiquement des PV Azure Files à l’aide des classes de stockage intégrées

Une classe de stockage permet de définir la façon dont un partage de fichiers Azure est créé. Un compte de stockage est automatiquement créé dans le groupe de ressources de nœud pour être utilisé avec la classe de stockage afin de contenir le partage de fichiers Azure. Faites votre choix parmi les références SKU de redondance de stockage Azure suivantes pour skuName :

• Standard_LRS : Stockage localement redondant standard
• Standard_GRS : Stockage géo-redondant standard
• Standard_ZRS : Stockage redondant dans une zone standard
• Standard_RAGRS : Stockage géo-redondant avec accès en lecture standard
• Standard_RAGZRS : stockage géo-redondant interzone avec accès en lecture Standard
• Premium_LRS : Stockage Premium localement redondant
• Premium_ZRS : stockage redondant interzone (ZRS) Premium

Remarque

Azure Files prend en charge les partages de fichier Premium Azure. La capacité du partage de fichiers minimal est de 100 Gio. Nous vous recommandons d’utiliser des partages de fichiers Azure Premium au lieu de partages de fichiers Standard, car les partages de fichiers Premium offrent des performances supérieures et une prise en charge des disques à faible latence pour les charges de travail nécessitant beaucoup d’E/S.

Quand vous utilisez des pilotes de stockage CSI sur AKS, il y a deux autres StorageClasses intégrées qui utilisent les pilotes de stockage CSI Azure Files. Les autres classes de stockage CSI sont créées avec le cluster en même temps que les classes de stockage par défaut dans l’arborescence.

• azurefile-csi : utilise le stockage Standard Azure pour créer un partage de fichiers Azure.
• azurefile-csi-premium : utilise le stockage Premium Azure pour créer un partage de fichiers Azure.

La stratégie de récupération sur les deux classes de stockage garantit que le partage de fichiers Azure sous-jacent est supprimé lorsque le volume persistant respectif est supprimé. Les classes de stockage configurent également les partages de fichiers pour qu’ils soient extensibles. Il vous suffit de modifier la revendication de volume persistant (PVC) avec la nouvelle taille.

Pour utiliser ces classes de stockage, créez un PVC et un pod respectif qui les référence et les utilise. Une revendication de volume persistant est utilisée pour configurer automatiquement le stockage basé sur une classe de stockage. Une revendication de volume persistant peut utiliser l’une des classes de stockage précréées ou une classe de stockage définie par l’utilisateur pour créer un partage de fichiers Azure pour le niveau tarifaire et la taille de votre choix. Quand vous créez une définition de pod, la revendication de volume persistant est spécifiée pour demander le stockage souhaité.

Créez un exemple de PVC et de pod qui imprime la date actuelle dans un outfile en exécutant les commandes kubectl apply :

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/pvc-azurefile-csi.yaml
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/nginx-pod-azurefile.yaml

La sortie de la commande ressemble à l’exemple suivant :

persistentvolumeclaim/pvc-azurefile created
pod/nginx-azurefile created

Une fois que le pod est en cours d’exécution, vous pouvez vérifier que le partage de fichiers est correctement monté en exécutant la commande suivante et en vérifiant que la sortie contient outfile :

kubectl exec nginx-azurefile -- ls -l /mnt/azurefile

La sortie de la commande ressemble à l’exemple suivant :

total 29
-rwxrwxrwx 1 root root 29348 Aug 31 21:59 outfile

Créer une classe de stockage personnalisée

Les classes de stockage par défaut sont adaptées aux scénarios les plus courants, mais pas à tous. Dans certains cas, vous souhaiterez peut-être personnaliser votre propre classe de stockage avec vos propres paramètres. Par exemple, utilisez le manifeste suivant pour configurer les mountOptions du partage de fichiers.

La valeur par défaut de fileMode et dirMode est 0777 pour les partages de fichiers montés Kubernetes. Vous pouvez spécifier les différentes options de montage sur l’objet de classe de stockage.

Créez un fichier nommé azure-file-sc.yaml et copiez-y l’exemple de manifeste suivant :

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: my-azurefile
provisioner: file.csi.azure.com
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
mountOptions:
  - dir_mode=0640
  - file_mode=0640
  - uid=0
  - gid=0
  - mfsymlinks
  - cache=strict # https://linux.die.net/man/8/mount.cifs
  - nosharesock
parameters:
  skuName: Standard_LRS

Créez la classe de stockage en exécutant la commande kubectl apply :

kubectl apply -f azure-file-sc.yaml

La sortie de la commande ressemble à l’exemple suivant :

storageclass.storage.k8s.io/my-azurefile created

Le pilote CSI pour Azure Files prend en charge la création de captures instantanées de volumes persistants et des partages de fichiers sous-jacents.

Créez une classe d’instantané de volume avec la commande kubectl apply :

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/snapshot/volumesnapshotclass-azurefile.yaml

La sortie de la commande ressemble à l’exemple suivant :

volumesnapshotclass.snapshot.storage.k8s.io/csi-azurefile-vsc created

Créez un instantané de volume à partir du PVC que nous avons créé de façon dynamique au début de ce tutoriel, pvc-azurefile.

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/snapshot/volumesnapshot-azurefile.yaml

La sortie de la commande ressemble à l’exemple suivant :

volumesnapshot.snapshot.storage.k8s.io/azurefile-volume-snapshot created

Vérifiez que l’instantané a été créé correctement en exécutant la commande suivante :

kubectl describe volumesnapshot azurefile-volume-snapshot

La sortie de la commande ressemble à l’exemple suivant :

Name:         azurefile-volume-snapshot
Namespace:    default
Labels:       <none>
Annotations:  API Version:  snapshot.storage.k8s.io/v1beta1
Kind:         VolumeSnapshot
Metadata:
  Creation Timestamp:  2020-08-27T22:37:41Z
  Finalizers:
    snapshot.storage.kubernetes.io/volumesnapshot-as-source-protection
    snapshot.storage.kubernetes.io/volumesnapshot-bound-protection
  Generation:        1
  Resource Version:  955091
  Self Link:         /apis/snapshot.storage.k8s.io/v1beta1/namespaces/default/volumesnapshots/azurefile-volume-snapshot
  UID:               c359a38f-35c1-4fb1-9da9-2c06d35ca0f4
Spec:
  Source:
    Persistent Volume Claim Name:  pvc-azurefile
  Volume Snapshot Class Name:      csi-azurefile-vsc
Status:
  Bound Volume Snapshot Content Name:  snapcontent-c359a38f-35c1-4fb1-9da9-2c06d35ca0f4
  Ready To Use:                        false
Events:                                <none>

Redimensionner un volume persistant

Vous pouvez demander un volume plus important pour un PVC. Modifiez l’objet PVC et spécifiez une taille supérieure. Cette modification déclenche l’expansion du volume sous-jacent qui stocke le PV.

Notes

Un nouveau PV n’est jamais créé pour satisfaire la revendication. Au lieu de cela, un volume existant est redimensionné.

La réduction des volumes persistants n’est actuellement pas prise en charge.

Dans AKS, la classe de stockage intégrée azurefile-csi prend déjà en charge l’expansion, vous pouvez donc utiliser le PVC créé précédemment avec cette classe de stockage. Le PVC a demandé un partage de fichiers de 100 Gio. Nous pouvons confirmer cela en exécutant :

kubectl exec -it nginx-azurefile -- df -h /mnt/azurefile

La sortie de la commande ressemble à l’exemple suivant :

Filesystem                                                                                Size  Used Avail Use% Mounted on
//f149b5a219bd34caeb07de9.file.core.windows.net/pvc-5e5d9980-da38-492b-8581-17e3cad01770  100G  128K  100G   1% /mnt/azurefile

Développez le PVC en augmentant le champ spec.resources.requests.storage :

kubectl patch pvc pvc-azurefile --type merge --patch '{"spec": {"resources": {"requests": {"storage": "200Gi"}}}}'

La sortie de la commande ressemble à l’exemple suivant :

persistentvolumeclaim/pvc-azurefile patched

Vérifiez que le PVC et le système de fichiers à l’intérieur du pod affichent la nouvelle taille :

kubectl get pvc pvc-azurefile
NAME            STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS    AGE
pvc-azurefile   Bound    pvc-5e5d9980-da38-492b-8581-17e3cad01770   200Gi      RWX            azurefile-csi   64m

kubectl exec -it nginx-azurefile -- df -h /mnt/azurefile
Filesystem                                                                                Size  Used Avail Use% Mounted on
//f149b5a219bd34caeb07de9.file.core.windows.net/pvc-5e5d9980-da38-492b-8581-17e3cad01770  200G  128K  200G   1% /mnt/azurefile

Utiliser un volume persistant avec un stockage Azure Files privé (point de terminaison privé)

Si vos ressources Azure Files sont protégées par un point de terminaison privé, vous devez créer votre propre classe de stockage. Vérifiez que vous avez configuré vos paramètres DNS pour changer l’adresse IP du point de terminaison privé par le nom de domaine complet (FQDN) de la chaîne de connexion. Personnaliser les paramètres suivants :

• resourceGroup : groupe de ressources dans lequel le compte de stockage est déployé.
• storageAccount : nom du compte de stockage.
• server : nom de domaine complet du point de terminaison privé du compte de stockage.

Créez un fichier nommé private-azure-file-sc.yaml, puis collez l’exemple de manifeste suivant dans le fichier. Remplacez les valeurs de <resourceGroup> et <storageAccountName>.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: private-azurefile-csi
provisioner: file.csi.azure.com
allowVolumeExpansion: true
parameters:
  resourceGroup: <resourceGroup>
  storageAccount: <storageAccountName>
  server: <storageAccountName>.file.core.windows.net
reclaimPolicy: Delete
volumeBindingMode: Immediate
mountOptions:
  - dir_mode=0777
  - file_mode=0777
  - uid=0
  - gid=0
  - mfsymlinks
  - cache=strict  # https://linux.die.net/man/8/mount.cifs
  - nosharesock  # reduce probability of reconnect race
  - actimeo=30  # reduce latency for metadata-heavy workload

Créez la classe de stockage en utilisant la commande kubectl apply :

kubectl apply -f private-azure-file-sc.yaml

La sortie de la commande ressemble à l’exemple suivant :

storageclass.storage.k8s.io/private-azurefile-csi created

Créez un fichier nommé private-pvc.yaml, puis collez l’exemple de manifeste suivant dans le fichier :

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: private-azurefile-pvc
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: private-azurefile-csi
  resources:
    requests:
      storage: 100Gi

Créez le PVC en utilisant la commande kubectl apply :

kubectl apply -f private-pvc.yaml

Partages de fichiers NFS

Azure Files prend en charge le protocole NFS v 4.1. La prise en charge de la version 4.1 du protocole NFS pour Azure Files vous donne un système de fichiers NFS complètement managé en tant que service, reposant sur une plateforme de stockage résiliente et distribuée hautement disponible et durable.

Cette option est optimisée pour les charges de travail à accès aléatoire avec des mises à jour de données sur place et fournit une prise en charge complète du système de fichiers POSIX. Cette section vous montre comment utiliser des partages NFS avec le pilote CSI d’Azure Files sur un cluster AKS.

Prérequis

• L’identité de Plan de contrôle de votre cluster AKS (autrement dit, le nom de votre cluster AKS) est ajoutée au rôle Contributeur sur le réseau virtuel et NetworkSecurityGroup.
• Votre principal de service ou votre identité MSI (Managed Service Identity) du cluster AKS doivent être ajoutés au rôle Contributeur sur le compte de stockage.

Notes

Vous pouvez utiliser un point de terminaison privé au lieu d’autoriser l’accès au réseau virtuel sélectionné.

Optimisation des options des tailles de lecture et d’écriture

Cette section fournit des informations sur le réglage des performances NFS avec le pilote CSI Azure Files en utilisant les options rsize et wsize. Les options rsize et wsize définissent la taille de transfert maximale d’une opération NFS. Si rsize ou wsize ne sont pas spécifiés au montage, le client et le serveur négocient la plus grande taille prise en charge par les deux. À l’heure actuelle, Azure NetApp Files et les distributions Linux modernes prennent en charge des tailles de lecture et d’écriture pouvant aller jusqu’à 1 048 576 octets (1 Mio).

Les performances optimales sont basées sur une communication client-serveur efficace. L’augmentation ou la diminution des valeurs de taille des options de lecture et d’écriture de montage peut améliorer les performances NFS. La taille par défaut des paquets de lecture/d’écriture transférés entre le client et le serveur est de 8 Ko pour NFS version 2, et de 32 Ko pour NFS versions 3 et 4. Ces valeurs par défaut peuvent être trop grandes ou trop petites. La réduction de rsize et wsize peut améliorer les performances NFS dans un réseau saturé en envoyant des paquets plus petits pour chaque demande d’écriture et de lecture de réponse NFS. Toutefois, cela peut augmenter le nombre de paquets nécessaires pour envoyer des données sur le réseau, ce qui augmente le trafic réseau total, et l’utilisation du processeur sur le client et le serveur.

Vous devez donc faire des tests pour trouver des valeurs de rsize et wsize qui favorisent un transfert de paquets efficace, sans réduire le débit ni augmenter la latence.

Pour plus d’informations sur l’optimisation de rsize et wsize, consultez Bonnes pratiques des options de montage NFS Linux pour Azure NetApp Files.

Par exemple, pour configurer des valeurs de rsize et wsize maximales de 256 Kio, configurez les mountOptions dans la classe de stockage de la façon suivante :

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: azurefile-csi-nfs
provisioner: file.csi.azure.com
allowVolumeExpansion: true
parameters:
  protocol: nfs
mountOptions:
  - nconnect=4
  - noresvport
  - actimeo=30
  - rsize=262144
  - wsize=262144

Créer une classe de stockage pour les partages de fichiers NFS

Créez un fichier nommé nfs-sc.yaml et copiez le manifeste ci-dessous. Pour obtenir la liste des mountOptions pris en charge, consultez les options de montage NFS.

Remarque

vers, minorversion, sec sont configurés par le pilote CSI de fichier Azure. La spécification d’une valeur dans votre manifeste pour ces propriétés n’est pas prise en charge.

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: azurefile-csi-nfs
provisioner: file.csi.azure.com
allowVolumeExpansion: true
parameters:
  protocol: nfs
mountOptions:
  - nconnect=4
  - noresvport
  - actimeo=30

Après avoir modifié et enregistré le fichier, créez la classe de stockage à l’aide de la commande kubectl apply :

kubectl apply -f nfs-sc.yaml

La sortie de la commande ressemble à l’exemple suivant :

storageclass.storage.k8s.io/azurefile-csi-nfs created

Créer un déploiement avec un partage de fichiers sauvegardé sur NFS

Vous pouvez déployer un exemple StatefulSet qui enregistre les horodatages (timestamps) dans un fichier data.txt à l’aide de la commande kubectl apply :

kubectl apply -f

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: statefulset-azurefile
  labels:
    app: nginx
spec:
  podManagementPolicy: Parallel  # default is OrderedReady
  serviceName: statefulset-azurefile
  replicas: 1
  template:
    metadata:
      labels:
        app: nginx
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
        - name: statefulset-azurefile
          image: mcr.microsoft.com/oss/nginx/nginx:1.19.5
          command:
            - "/bin/bash"
            - "-c"
            - set -euo pipefail; while true; do echo $(date) >> /mnt/azurefile/outfile; sleep 1; done
          volumeMounts:
            - name: persistent-storage
              mountPath: /mnt/azurefile
  updateStrategy:
    type: RollingUpdate
  selector:
    matchLabels:
      app: nginx
  volumeClaimTemplates:
    - metadata:
        name: persistent-storage
      spec:
        storageClassName: azurefile-csi-nfs
        accessModes: ["ReadWriteMany"]
        resources:
          requests:
            storage: 100Gi

La sortie de la commande ressemble à l’exemple suivant :

statefulset.apps/statefulset-azurefile created

Validez le contenu du volume en exécutant la commande suivante :

kubectl exec -it statefulset-azurefile-0 -- df -h

La sortie de la commande ressemble à l’exemple suivant :

Filesystem      Size  Used Avail Use% Mounted on
...
/dev/sda1                                                                                 29G   11G   19G  37% /etc/hosts
accountname.file.core.windows.net:/accountname/pvc-fa72ec43-ae64-42e4-a8a2-556606f5da38  100G     0  100G   0% /mnt/azurefile
...

Notes

Notez que la taille du partage de fichiers minimale est de 100 Gio, car le partage de fichiers NFS se trouve dans un compte Premium. Si vous créez un PVC avec une petite taille de stockage, vous risquez de rencontrer une erreur de type : impossible de créer le partage de fichiers ... taille (5)....

Conteneurs Windows

Le pilote CSI pour Azure Files prend également en charge les nœuds et conteneurs Windows. Pour utiliser des conteneurs Windows, suivez le Guide de démarrage rapide sur les conteneurs Windows afin d’ajouter un pool de nœuds Windows.

Dès que vous avez un pool de nœuds Windows, utilisez les classes de stockage intégrées comme azurefile-csi ou créez des classes personnalisées. Vous pouvez déployer un exemple d’ensemble avec état basé sur Windows qui enregistre les horodatages dans un fichier data.txt en exécutant la commande kubectl apply suivante :

kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/azurefile-csi-driver/master/deploy/example/windows/statefulset.yaml

La sortie de la commande ressemble à l’exemple suivant :

statefulset.apps/busybox-azurefile created

Validez le contenu du volume en exécutant la commande kubectl exec suivante :

kubectl exec -it busybox-azurefile-0 -- cat c:\\mnt\\azurefile\\data.txt # on Linux/MacOS Bash
kubectl exec -it busybox-azurefile-0 -- cat c:\mnt\azurefile\data.txt # on Windows Powershell/CMD

La sortie des commandes ressemble à l’exemple suivant :

2020-08-27 22:11:01Z
2020-08-27 22:11:02Z
2020-08-27 22:11:04Z
(...)

Étapes suivantes

• Pour savoir comment utiliser le pilote CSI pour les disques Azure, consultez Utiliser des disques Azure avec un pilote CSI.
• Pour utiliser le pilote CSI pour Stockage Blob Azure, consultez Utiliser Stockage Blob Azure avec les pilotes CSI.
• Pour plus d’informations sur les meilleures pratiques relatives au stockage, consultez Meilleures pratiques relatives au stockage et aux sauvegardes dans Azure Kubernetes Service.