Despliegue de una instancia de Redis con un volumen NVM montado como memoria directa -

En Container Service for Kubernetes (ACK), el acceso directo a dispositivos de memoria persistente (PMEM) permite lograr un alto throughput y baja latencia. Este tema describe cómo usar memoria dinámica de acceso aleatorio (DRAM) y PMEM para desplegar instancias de Redis en memoria que requieren gran capacidad de memoria.

Información de contexto

Si desea desplegar instancias de Redis en memoria que requieran gran capacidad de memoria, puede montar volúmenes NVM (memoria no volátil) como memoria directa. Esta solución ofrece los siguientes beneficios:

Se accede a los volúmenes NVM de manera declarativa. Esto simplifica el uso de recursos NVM.
Con la misma capacidad de memoria, los costos se reducen entre un 30% y un 50%.
Se minimizan las modificaciones en las aplicaciones.

Redis usa dispositivos NVM como memoria directa e invoca la función MMAP para asignar el espacio de direcciones contiguo de la PMEM. En este caso, se requieren versiones específicas de Redis. Los siguientes ejemplos muestran cómo consultar las imágenes de las instancias de Redis.

Uso de DRAM para desplegar una instancia de Redis en memoria

La DRAM ofrece un rendimiento de acceso de alta velocidad, pero pierde datos cuando se corta la energía. La DRAM no es adecuada para escenarios a gran escala debido a sus altos costos.

Siga estos pasos para desplegar una instancia de Redis:

Use la siguiente plantilla de ejemplo para crear un archivo redis-normal.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-normal
  labels:
    app: redis-normal
spec:
  selector:
    matchLabels:
      app: redis-normal
  template:
    metadata:
      labels:
        app: redis-normal
    spec:
      containers:
      - name: redis
        image: registry.cn-hangzhou.aliyuncs.com/plugins/redis:v1-normal
        imagePullPolicy: Always
        resources:
          requests:
            memory: 30Gi
          limits:
            memory: 30Gi

Ejecute el siguiente comando para desplegar la instancia de Redis:
```
kubectl apply -f redis-normal.yaml
```

Ejecute el siguiente comando para consultar el pod que ejecuta la instancia de Redis:
```
kubectl get pod | grep redis-normal
```
Salida esperada:
```
redis-normal-***         1/1     Running   0          4d8h
```
Ejecute el siguiente comando para probar el rendimiento de escritura de la instancia de Redis:
```
LD_PRELOAD=/usr/local/lib/libmemkind.so redis-benchmark -d 102400 -t set -n 1000000 -r 1000000
```
Salida esperada:
```
1000000 requests completed in 13.03 seconds
76751.86 requests per second
```
La salida anterior muestra que la instancia de Redis en memoria desplegada con DRAM puede procesar aproximadamente 76,751 solicitudes por segundo.

Uso de PMEM para desplegar una instancia de Redis en memoria

La PMEM proporciona almacenamiento no volátil y es similar a la DRAM en método y velocidad de acceso.

Ejecute el siguiente comando para desplegar una instancia de Redis en memoria:

kubectl apply -f redis-normal.yaml

La siguiente plantilla muestra un ejemplo del archivo redis-normal.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pmem-pvc-direct
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 60Gi
  storageClassName: csi-pmem-direct
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-pmem-direct
  labels:
    app: redis-pmem-direct
spec:
  selector:
    matchLabels:
      app: redis-pmem-direct
  template:
    metadata:
      labels:
        app: redis-pmem-direct
    spec:
      containers:
      - name: nginx
        image: registry.cn-hangzhou.aliyuncs.com/plugins/redis:v1-pmem
        imagePullPolicy: Always
        volumeMounts:
          - name: pmem-pvc
            mountPath: "/mnt/pmem"
      volumes:
        - name: pmem-pvc
          persistentVolumeClaim:
            claimName: pmem-pvc-direct

Ejecute el siguiente comando para consultar el pod que ejecuta la instancia de Redis:

kubectl get pod | grep redis-pmem-direct

Salida esperada:

redis-pmem-direct-5b469546db-5tk2j   1/1     Running   0          4d9h

Ejecute el siguiente comando para probar el rendimiento de escritura de la instancia de Redis:
```
LD_PRELOAD=/usr/local/lib/libmemkind.so redis-benchmark -d 10240 -t set -n 1000000 -r 1000000
```
Salida esperada:
```
1000000 requests completed in 19.89 seconds
50266.41 requests per second
```
La salida anterior indica que la instancia de Redis en memoria desplegada con PMEM puede procesar alrededor de 50,266 solicitudes por segundo.

En comparación con la instancia de Redis en memoria desplegada con DRAM, la instancia con PMEM reduce el rendimiento de escritura en un 34%, pero mantiene el mismo rendimiento de lectura y genera un ahorro de costos del 50%. Los tipos de instancia de Elastic Compute Service (ECS) con dispositivos NVM, como ecs.ebmre6p.26xlarge, ofrecen 1.5 TB de memoria MEM, lo que representa cinco veces la capacidad de las bases de datos en memoria comunes.