:Utiliser EFC pour accélérer l'accès aux systèmes de fichiers NASou CPFS

ou CPFS

Prérequis

• Le système d'exploitation d'une instance Elastic Compute Service (ECS) doit être Alibaba Cloud Linux 2, avec une version de noyau 4.19.91-23 ou ultérieure.

• Un cluster ACK Pro exécutant Kubernetes 1.18 ou une version ultérieure doit être créé. Pour plus d'informations, consultez Créer un cluster ACK Pro.

• Le service NAS doit être activé. Les nœuds du cluster ACK Pro créé doivent pouvoir monter et accéder à un système de fichiers NAS de type Capacité ou Performance .

  Remarque

  Dans les scénarios d'entraînement IA, nous vous recommandons de sélectionner les types de systèmes de fichiers NAS en fonction du débit requis par les tâches d'entraînement. Pour plus d'informations, consultez Guide de sélection

• Un client kubectl doit être connecté au cluster ACK Pro. Pour plus d'informations, consultez Se connecter à un cluster ACK avec kubectl.

Présentation d'EFC

Utiliser Fluid EFCRuntime pour accélérer l'accès aux systèmes de fichiers NAS

Fluid utilise des ressources Kubernetes personnalisées liées à Fluid EFCRuntime pour se connecter à EFC. Cela permet de mettre en œuvre l'observabilité et la scalabilité des jeux de données.

Limites

Les limites suivantes s'appliquent à Fluid EFCRuntime :

• Fluid EFCRuntime ne prend pas en charge le préchargement du cache DataLoad. La mise en cache des données intervient uniquement lors du premier accès.

• Fluid EFCRuntime n'expose pas l'état de mise en cache des jeux de données.

• Fluid EFCRuntime est pris en charge uniquement dans les régions suivantes : Chine (Zhangjiakou), Chine (Pékin), Chine (Guangzhou), Chine (Shenzhen) et Chine (Shanghai).

Fonctionnement de Fluid EFCRuntime

La figure suivante illustre la manière dont Fluid EFCRuntime met en cache les données provenant de NAS vers le stockage local pour accélérer l'accès aux données. La section suivante décrit le fonctionnement de Fluid EFCRuntime :

1. Créez des définitions de ressources personnalisées (CRD) pour les jeux de données et les EFCRuntimes afin de spécifier les informations relatives aux systèmes de fichiers NAS sources .

2. Les contrôleurs Fluid déploient les composants EFC Cache Worker et EFC FUSE en fonction des informations relatives aux systèmes de fichiers sources.

3. Lorsque vous créez un pod, utilisez une revendication de volume persistant (PVC) pour monter la cible de montage d'un système de fichiers exposée par le client EFC FUSE dans le pod.

4. Lorsque vous accédez aux données d'un système de fichiers NAS monté, le client EFC FUSE transfère la requête à EFC Cache Worker. EFC Cache Worker vérifie si les données sont mises en cache dans le stockage local. Si les données sont mises en cache localement, vous pouvez y accéder directement. Sinon, EFC Cache Worker lit les données depuis le système de fichiers NAS et les met en cache dans le stockage local. Vous pouvez ensuite accéder au cache dans le stockage local.

• Dataset (jeu de données) : une CRD définie par Fluid. Un jeu de données est un ensemble de données logiquement liées utilisées par les moteurs de calcul de niveau supérieur.

• EFCRuntime : un runtime qui accélère l'accès aux jeux de données. Les EFCRuntimes utilisent EFC comme moteur de mise en cache. Les moteurs de mise en cache EFC incluent les composants EFC Cache Worker et EFC FUSE.

  • EFC Cache Worker : un composant côté serveur qui active la mise en cache basée sur le hachage cohérent. Vous pouvez désactiver ce composant selon vos besoins. Une fois ce composant désactivé, les caches en lecture seule distribués sont désactivés. Les autres fonctionnalités ne sont pas affectées.

  • EFC FUSE : un composant client d'EFC qui expose des interfaces d'accès aux données via le protocole POSIX.

Procédure

Étape 1 : Installer ack-fluid

Installez la suite cloud-native AI et ack-fluid version 0.9.10 ou ultérieure.

Étape 2 : Écrire des données dans le système de fichiers NAS

1. Montez le système de fichiers NAS sur une instance ECS. Pour plus d'informations, consultez Monter un système de fichiers NFS en un clic.

2. Exécutez la commande suivante pour interroger la cible de montage du système de fichiers CPFS :

   findmnt /mnt

   Sortie attendue :

   TARGET   SOURCE                                         FSTYPE OPTIONS
   /mnt/nfs xxxxxxxxxxx-xxxxx.cn-beijing.nas.aliyuncs.com:/ nfs    rw,relatime,vers=3,rsize=1048576,wsize=1048576,namlen=255,hard,nolock,no

3. Exécutez la commande suivante pour créer un fichier de 10 Go dans le répertoire de montage du système de fichiers NAS :

   dd if=/dev/zero of=/mnt/nfs/allzero-demo count=1024 bs=10M

   Sortie attendue :

   1024+0 records in
   1024+0 records out
   10737418240 bytes (11 GB) copied, 50.9437 s, 211 MB/s

Étape 3 : Créer un jeu de données et un EFCRuntime

1. Créez un fichier nommé dataset.yaml et copiez-y le contenu suivant :

   Modèle d'exemple pour un système de fichiers NAS

   apiVersion: data.fluid.io/v1alpha1
   kind: Dataset
   metadata:
     name: efc-demo
   spec:
     mounts:
       - mountPoint: "nfs://<nas_url>:<nas_dir>"
         name: efc
         path: "/"
   ---
   apiVersion: data.fluid.io/v1alpha1
   kind: EFCRuntime
   metadata:
     name: efc-demo
   spec:
     replicas: 3
     master:
       networkMode: ContainerNetwork
     worker:
       networkMode: ContainerNetwork
     fuse:
       networkMode: ContainerNetwork
     tieredstore:
       levels:
         - mediumtype: MEM
           path: /dev/shm
           quota: 15Gi

   Le fichier dataset.yaml sert à créer un jeu de données et un EFCRuntime.

   • Le jeu de données spécifie les informations relatives au système de fichiers NAS , telles que l'URL du système de fichiers NAS et le répertoire que vous souhaitez monter.

   • L'EFCRuntime démarre un système de mise en cache EFC pour fournir des services de mise en cache. Vous pouvez spécifier le nombre de pods répliqués pour le composant worker du système de mise en cache EFC ainsi que la capacité de cache de chaque composant worker.

   Paramètre	Description
   mountPoint	Si vous utilisez un système de fichiers NAS, définissez la valeur au format nfs://<nas_url>:<nas_dir>. nas_url : URL du système de fichiers NAS. Pour obtenir l'URL du système de fichiers NAS, effectuez les opérations suivantes : Connectez-vous à la console NAS. Dans le volet de navigation de gauche, choisissez File System > File System List. Sur la page File System List, recherchez le système de fichiers NAS que vous souhaitez monter et cliquez sur Manage dans la colonne Actions. Sur la page qui s'affiche, cliquez sur Mount Targets. Pour plus d'informations, consultez Gérer les points de montage. nas_dir : sous-répertoire que vous souhaitez monter. Dans la plupart des cas, vous pouvez définir la valeur sur le répertoire racine. Par exemple, une valeur de efc://xxxxxxxxxxx-xxxxx.cn-beijing.nas.aliyuncs.com:/ spécifie le répertoire racine d'un système de fichiers NAS.
   replicas	Nombre de pods répliqués créés pour le composant worker du système de mise en cache EFC. Définissez la valeur en fonction de la taille de la mémoire du nœud de calcul et de la taille du jeu de données. Nous vous recommandons de vous assurer que le produit de la valeur de quota et de la valeur de replicas est supérieur à la taille du jeu de données.
   networkMode	Valeurs valides : ContainerNetwork et HostNetwork. Dans l'environnement ACK, nous vous recommandons de définir la valeur sur ContainerNetwork. Ce mode réseau ne compromet pas les performances réseau.
   mediumtype	Type de cache. Valeurs valides : HDD, SSD et MEM. La valeur MEM indique la mémoire. Dans les scénarios d'entraînement IA, nous vous recommandons de définir ce paramètre sur MEM. Si vous définissez ce paramètre sur MEM, vous devez définir le paramètre path sur un système de fichiers en mémoire, tel que tmpfs.
   path	Répertoire de cache dans les pods des composants worker du système de mise en cache EFC. Nous vous recommandons de définir la valeur de ce paramètre sur /dev/shm.
   quota	Capacité de cache de chaque composant worker. Définissez la valeur en fonction de la taille de la mémoire du nœud de calcul et de la taille du jeu de données. Nous vous recommandons de vous assurer que le produit de la valeur de quota et de la valeur de replicas est supérieur à la taille du jeu de données.

2. Exécutez la commande suivante pour créer un EFCRuntime et un jeu de données :

   kubectl create -f dataset.yaml

3. Exécutez la commande suivante pour vérifier si le Dataset est déployé :

   kubectl get dataset efc-demo

   Sortie attendue :

   NAME       UFS TOTAL SIZE   CACHED   CACHE CAPACITY   CACHED PERCENTAGE   PHASE   AGE
   efc-demo                                                                  Bound   24m

   Le jeu de données est à l'état Bound. Cela indique que le système de mise en cache EFC fonctionne comme prévu dans le cluster et que les pods d'application peuvent accéder aux données fournies par le jeu de données.

4. Exécutez la commande suivante pour vérifier si l'EFCRuntime est déployé :

   kubectl get efcruntime

   Sortie attendue :

   NAME       MASTER PHASE   WORKER PHASE   FUSE PHASE   AGE
   efc-demo   Ready          Ready          Ready        27m

   Les résultats indiquent que les composants master, worker et FUSE sont à l'état Ready.

5. Exécutez les commandes suivantes pour vérifier si le volume persistant (PV) et la PVC sont créés :

   Une fois le jeu de données et le système de mise en cache EFC prêts, Fluid crée automatiquement une PVC et un PV.

   kubectl get pv,pvc

   Sortie attendue :

   NAME                                CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                    STORAGECLASS   REASON   AGE
   persistentvolume/default-efc-demo   100Gi      ROX            Retain           Bound    default/efc-demo         fluid                   94m
   
   NAME                                   STATUS   VOLUME             CAPACITY   ACCESS MODES   STORAGECLASS   AGE
   persistentvolumeclaim/efc-demo         Bound    default-efc-demo   100Gi      ROX            fluid          94m

Étape 4 : Créer une application pour accéder aux données

Créez une application pour vérifier si l'accès aux données est accéléré. Dans cet exemple, une application provisionnant deux pods est créée et utilisée pour accéder plusieurs fois au système de fichiers NAS depuis deux nœuds. Évaluez les performances d'accélération de Fluid EFCRuntime en fonction du temps nécessaire à l'accès aux données.

1. Créez un fichier nommé app.yaml et copiez-y le contenu suivant.

   Le contenu suivant définit un StatefulSet nommé efc-app. Le StatefulSet contient deux pods. Chaque pod monte la PVC efc-demo dans le répertoire /data.

   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
     name: efc-app
     labels:
       app: nginx
   spec:
     serviceName: nginx
     replicas: 2
     selector:
       matchLabels:
         app: nginx
     template:
       metadata:
         labels:
           app: nginx
       spec:
         containers:
         - name: nginx
           image: registry.openanolis.cn/openanolis/nginx:1.14.1-8.6
           command: ["/bin/bash"]
           args: ["-c", "sleep inf"]
           volumeMounts:
           - mountPath: "/data"
             name: data-vol
         volumes:
           - name: data-vol
             persistentVolumeClaim:
               claimName: efc-demo

2. Exécutez la commande suivante pour créer un StatefulSet nommé efc-app :

   kubectl create -f app.yaml

3. Exécutez la commande suivante pour interroger la taille du fichier spécifié :

   kubectl exec -it efc-app-0 -- du -h /data/allzero-demo

   Sortie attendue :

   10G     /data/allzero-demo

4. Interrogez le temps nécessaire pour lire le fichier spécifié depuis l'application.

   Remarque

   Le temps et le débit peuvent varier en fonction de l'environnement d'exécution et de la méthode de mesure. Dans cette rubrique, le cluster dispose de trois instances ECS de type ecs.g7ne.8xlarge. L'EFCRuntime efc-demo comporte trois pods worker qui s'exécutent sur la même instance ECS. Le StatefulSet efc-app comporte deux pods qui s'exécutent séparément sur les deux autres instances ECS. Le temps nécessaire à l'accès aux données n'est pas affecté par le cache du noyau du nœud sur lequel s'exécute le client EFC FUSE.

   1. Exécutez la commande suivante pour vérifier le temps nécessaire pour lire le fichier spécifié depuis le pod efc-app-0 du StatefulSet :

      Remarque

      Si vous souhaitez lire un autre fichier, remplacez /data/allzero-demo par le chemin du fichier.

      kubectl exec -it efc-app-0 -- bash -c "time cat /data/allzero-demo > /dev/null"

      Sortie attendue :

      real    0m15.792s
      user    0m0.023s
      sys     0m2.404s

      Les résultats indiquent qu'il faut 15,792 secondes pour lire un fichier de 10 Go et que la vitesse de lecture est de 648 MiB/s.

   2. Exécutez la commande suivante pour vérifier le temps nécessaire pour lire le même fichier de 10 Go depuis l'autre pod du StatefulSet :

      Remarque

      Si vous souhaitez lire un autre fichier, remplacez /data/allzero-demo par le chemin du fichier.

      kubectl exec -it efc-app-1 -- bash -c "time cat /data/allzero-demo > /dev/null"

      Sortie attendue :

      real    0m9.970s
      user    0m0.012s
      sys     0m2.283s

      Les résultats indiquent qu'il faut 9,970 secondes pour lire un fichier de 10 Go et que la vitesse de lecture est de 1 034,3 MiB/s.

   Après l'utilisation de Fluid EFCRuntime, la vitesse de lecture passe de 648 MiB/s à 1 034,3 MiB/s. Pour le même fichier, Fluid EFCRuntime augmente la vitesse de lecture d'environ 100 %.