How to enable the distributed caching feature of the CNFS client - File Storage NAS

El cliente Container Network File System (CNFS) permite acceder a los datos mediante varias conexiones, almacenar metadatos en la caché y guardar datos de forma distribuida para aumentar la velocidad de lectura. También admite el monitoreo de rendimiento y la calidad de servicio (QoS). En este tema se describe cómo habilitar la función de caché distribuido del cliente CNFS y cómo utilizarla para mejorar la velocidad de lectura.

Requisitos previos

Se utiliza Alibaba Cloud Linux 2 con una versión de kernel comprendida entre 4.19.91-23 y 4.19.91-26. La función de caché distribuido es compatible con Alibaba Cloud Linux 2.
Se creó un clúster de Container Service for Kubernetes (ACK) que ejecuta Kubernetes 1.20 o una versión posterior. El plugin Container Storage Interface (CSI) se usa como plugin de volumen. Para obtener más información, consulte Create an ACK managed cluster.
Las versiones de csi-plugin y csi-provisioner son v1.22.11-abbb810e-aliyun o posteriores. Para obtener más información sobre cómo actualizar csi-plugin y csi-provisioner, consulte Install and update the CSI plug-in.
La versión de storage-operator es v1.22.86-041b094-aliyun o posterior. Para obtener más información sobre cómo actualizar storage-operator, consulte Manage components.
Un cliente kubectl está conectado al clúster. Para obtener más información, consulte Connect to an ACK cluster using kubectl.

Indicadores clave de rendimiento de la función de caché distribuido

Indicador	Escenario de prueba de referencia^①	Caché distribuido deshabilitado	Caché distribuido habilitado
Rendimiento de lectura y escritura de metadatos	Tiempo para recorrer un millón de directorios	18 minutos	< 60 segundos
	Tiempo para crear un archivo de 4 KB	3000 microsegundos	< 200 microsegundos
	Tiempo para leer por segunda vez un archivo de 4 KB	400 microsegundos	< 100 microsegundos
Rendimiento de lectura y escritura	Rendimiento de lectura y escritura de un solo nodo^②	De 200 a 500 MB/s	> 800 MB/s
Rendimiento general en escenarios integrales	Tiempo para extraer 5000 imágenes de 150 KB cada una	52 segundos	Aproximadamente 15 segundos
Rendimiento general en escenarios integrales	Tiempo para crear un proyecto de Redis	27 segundos	Aproximadamente 21 segundos

Importante

Los valores de la tabla anterior son únicamente teóricos y sirven como referencia. Los valores reales dependen de su entorno operativo.

Nota ①: el tipo de instancia de Elastic Compute Service (ECS) utilizada para ejecutar la prueba de referencia es ecs.hfg6.4xlarge. Los datos de referencia pueden variar según el entorno.
Nota ②: el ancho de banda de la instancia ECS y el tipo de sistema de archivos File Storage NAS (NAS) afectan el rendimiento de lectura y escritura del nodo.

Paso 1: Montar un sistema de archivos NAS con el caché distribuido habilitado

Ejecute el siguiente comando para crear y desplegar el ConfigMap de csi-plugin en el clúster e instalar el cliente CNFS:

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ConfigMap
metadata:
  name: csi-plugin
  namespace: kube-system
data:
  cnfs-client-properties: |
    nas-efc=true
  nas-efc-cache: |
    enable=true
    container-number=3
    volume-type=memory
    volume-size=15Gi
  node-selector: |
    cache=true
EOF

Parámetro	Descripción
cnfs-client-properties	Indica si se habilita el caché distribuido. Si especifica `nas-efc=true`, se habilita esta función para aumentar la velocidad de lectura.
nfs-efc-cache. container-number	Este parámetro es obligatorio si habilita el caché distribuido. Define la cantidad de contenedores que el DaemonSet crea para la función de caché. Si dicha función alcanza un cuello de botella de rendimiento, puede aumentar el valor de este parámetro.
nfs-efc-cache. volume-type	Este parámetro es obligatorio si habilita el caché distribuido. Medio que utiliza el volumen emptyDir del pod creado por el DaemonSet. Valores válidos: `disk` `memory`
nfs-efc-cache. volume-size	Este parámetro es obligatorio si habilita el caché distribuido. Tamaño del volumen que desea almacenar en la caché. Unidad: GiB.
node-selector	El pod que crea el DaemonSet para la función de caché distribuido se programa según las etiquetas. Si no especifica este parámetro, el DaemonSet se programa en cada nodo del clúster.

Importante

Después de establecer el medio en disk o memory, se utilizan los recursos de disco de datos o de memoria del nodo. Compruebe que esto no afecte negativamente sus cargas de trabajo.
En este ejemplo, el DaemonSet de la función de caché distribuido crea tres contenedores. Cada uno tiene montado un volumen tmpfs de 5 GiB. Estos contenedores solo se pueden programar en un nodo que tenga la etiqueta cache=true.

Una vez configurado el ConfigMap, el sistema despliega automáticamente el DaemonSet y el Service correspondientes.

Ejecute el siguiente comando para reiniciar CSI-Plugin e instalar las dependencias:

kubectl get pod -nkube-system -owide | grep csi-plugin | awk '{print $1}' | xargs kubectl -nkube-system delete pod

Ejecute el siguiente comando para habilitar la función de caché distribuido del cliente CNFS:

Cree un sistema de archivos NAS gestionado por CNFS. El StatefulSet monta el volumen NAS acelerado por CNFS como un volumen aprovisionado dinámicamente. En este ejemplo se utiliza la imagen busybox. Después de iniciar el pod, el sistema ejecuta el comando dd para escribir un archivo de 1 GB en la ruta /data. Este archivo sirve para comprobar si la función de caché distribuido surte efecto.

Mostrar contenido YAML:

cat << EOF | kubectl apply -f -
apiVersion: storage.alibabacloud.com/v1beta1
kind: ContainerNetworkFileSystem
metadata:
  name: cnfs-nas-filesystem
spec:
  description: "cnfs"
  type: nas
  reclaimPolicy: Retain
  parameters:
    filesystemType: standard
    storageType: Capacity
    protocolType: NFS
    encryptType: None
    enableTrashCan: "true"
    trashCanReservedDays: "5"
    useClient: "EFCClient" # Use the EFC client to mount a NAS file system that has distributed caching enabled. 
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: alibabacloud-cnfs-nas-sc
mountOptions:
  - g_tier_EnableClusterCache=true              # Configure caching settings when mounting the volume. 
  - g_tier_EnableClusterCachePrefetch=true      # Configure prefetching when mounting the volume. 
parameters:
  volumeAs: subpath
  containerNetworkFileSystem: cnfs-nas-filesystem
  path: "/"
provisioner: nasplugin.csi.alibabacloud.com
reclaimPolicy: Retain
allowVolumeExpansion: true
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: cnfs-nas-sts
  labels:
    app: busybox
spec:
  serviceName: "busybox"
  replicas: 1
  selector:
    matchLabels:
      app: busybox
  template:
    metadata:
      labels:
        app: busybox
    spec:
      containers:
      - name: busybox
        image: busybox
        command: ["/bin/sh"]
        args: ["-c", "dd if=/dev/zero of=/data/1G.tmpfile bs=1G count=1;sleep 3600;"]
        volumeMounts:
        - mountPath: "/data"
          name: www
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: "alibabacloud-cnfs-nas-sc"
      resources:
        requests:
          storage: 50Gi
EOF

Ejecute el siguiente comando para comprobar si se montó el volumen NAS con el caché distribuido habilitado:
```
kubectl exec cnfs-nas-sts-0   -- mount | grep /data
```
Salida esperada:
```
xxx.cn-xxx.nas.aliyuncs.com:/nas-6b9d1397-6542-4410-816b-4dfd0633****:2fMaQdxU on /data type alifuse.aliyun-alinas-eac (rw,nosuid,nodev,relatime,user_id=0,group_id=0,default_permissions,allow_other)
```
Si la salida muestra un destino de montaje, significa que el volumen NAS con el caché distribuido habilitado se montó correctamente.

Ejecute el siguiente comando para comprobar si se inició el DaemonSet de la función de caché distribuido:

kubectl get ds/cnfs-cache-ds -n kube-system -owide

Salida esperada:

NAME             DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE   CONTAINERS              IMAGES                                                         SELECTOR
cnfs-cache-ds   3         3         3       3            3           <none>          19d   alinas-dadi-container   registry-vpc.cn-shenzhen.aliyuncs.com/acs/nas-cache:20220420   app=cnfs-cache-ds

En este ejemplo, el clúster contiene tres nodos. Los tres pods creados por el DaemonSet están listos, lo cual indica que dicho DaemonSet se inició correctamente.

Ejecute el siguiente comando para comprobar si el Service de caché distribuido detecta los pods de backend:
```
kubectl get ep cnfs-cache-ds-service  -n kube-system -owide
```
Salida esperada:
```
NAME                     ENDPOINTS                                          AGE
cnfs-cache-ds-service   10.19.1.130:6500,10.19.1.40:6500,10.19.1.66:6500   19d
```
La salida muestra que el Service detectó los pods de backend. Los endpoints de dichos pods son 10.19.1.130, 10.19.1.40 y 10.19.1.66, y el puerto es 6500.

Paso 2: Comprobar la función de caché

Ejecute el siguiente comando para copiar tmpfile del directorio /data al directorio / y medir el tiempo empleado. El tamaño del archivo es de 1 GB.
```
kubectl exec cnfs-nas-sts-0 -- time cp /data/1G.tmpfile /
```
Salida esperada:
```
real    0m 5.66s
user    0m 0.00s
sys     0m 0.75s
```
La salida indica que, con la función de caché distribuido deshabilitada, copiar el archivo toma aproximadamente cinco segundos.
Ejecute el siguiente comando varias veces para medir el tiempo necesario para copiar el archivo:
```
kubectl exec cnfs-nas-sts-0 -- time cp /data/1G.tmpfile /
```
Salida esperada:
```
real    0m 0.79s
user    0m 0.00s
sys     0m 0.58s
```
La salida muestra que el tiempo de copia se reduce entre seis y siete veces cuando se accede al archivo más de una vez.