# 🇫🇷 Kit de survie K8S pour les dévs avec K3S - Partie 6: Redis

Dans le précédent article (opens new window), nous avons vu comment utiliser les volumes pour persister des données. Nous allons utiliser cela pour déployer une base Redis avec des données persistantes dans notre cluster.

# Préalable

Nous allons "pousser" une image de la base Redis vers notre registry privée (vous pouvez bien sûr utiliser le Docker Hub à la place, mais l'avntage de l'avoir dans notre registry, c'est que nous pourrons la ré-utiliser beaucoup plus rapidement):

registry_domain="registry.dev.test"
docker pull redis:5.0.7-alpine
docker tag redis:5.0.7-alpine ${registry_domain}:5000/redis:5.0.7-alpine
docker push ${registry_domain}:5000/redis:5.0.7-alpine

# pour vérifier:
curl http://${registry_domain}:5000/v2/redis/tags/list

# Création d'un volume

Créez un fichier pvc.redis.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: local-path-pvc
  namespace: database
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: local-path
  resources:
    requests:
      storage: 100Mi

Ensuite, créez un nouveau namespace database:

kubectl create namespace database

Puis:

kubectl create -f pvc.redis.yaml

# Déployer Redis

Dans le même namespace, grâce à un fichier redis.yaml

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-master
  labels:
    app: redis
  namespace: database
spec:
  selector:
    matchLabels:
      app: redis
      role: master
      tier: backend
  replicas: 1
  template:
    metadata:
      labels:
        app: redis
        role: master
        tier: backend
    spec:
      containers:
        - name: master
          image: registry.dev.test:5000/redis:5.0.7-alpine
          volumeMounts:
            - name: data-volume
              mountPath: /data
          resources:
            requests:
              cpu: 100m
              memory: 100Mi
          ports:
            - containerPort: 6379
      volumes:
        - name: data-volume
          persistentVolumeClaim:
            claimName: local-path-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: redis-master
  labels:
    app: redis
    role: master
    tier: backend
  namespace: database
spec:
  ports:
    - port: 6379
      targetPort: 6379
  selector:
    app: redis
    role: master
    tier: backend

Puis:

kubectl appply -f redis.yaml

📘 Réf: https://kubernetes.io/docs/tutorials/stateless-application/guestbook (opens new window)

je n'ai pas créé un cluster Redis, ma base n'a qu'un seul noeud

# Utiliser Redis

Pour pouvoir utiliser notre base Redis, nous allons créer un nouveau pod (à partir de notre image "utilitaires") dans le napespace database. Pour cela, créez un nouveau fichier: pod.redis.client.yaml

apiVersion: v1
kind: Pod
metadata:
  name: redis-client
  namespace: database
spec:
  containers:
  - name: redis-client
    image: registry.dev.test:5000/mytools:0.0.0
    imagePullPolicy: IfNotPresent
    command:
      - sleep
      - "3600"

Créez le pod:

kubectl create -f pod.redis.client.yaml

Accédez au shell du pod:

kubectl exec -n database -it redis-client -- /bin/bash

Une fois "dans" le pod, connectez vous à la base Redis:

redis-cli -h redis-master

Vous pouvez tapez quelques commandes:

redis-master:6379> set firstname bob
OK
redis-master:6379> set lastname morane
OK
redis-master:6379> get firstname
"bob"
redis-master:6379> get lastname
"morane"
redis-master:6379>

pour quitter Redis: exit

pour quitter le shell du pod: exit

✋✋✋ Si vous supprimez le pod Redis, il va se re-créer, et vous pourrez vérifier à partir de votre pod client que les données sont toujours accessibles. Et faites le test en re-démarrant le cluster, vos données seront encore accessibles.

# Se connecter à partir d'un autre namespace

Si vous voulez vous connectez à votre service redis-master du namespace database à partir d'un autre namespace, il vous suffira d'utiliser <service_name>.<namespace_name> donc dans notre cas redis-master.database. Mais ce sera plus explicite avec un exemple:

Créez un pod "utilitaire" dans le namespace training, à partir d'un fichier pod.redis.client.2.yaml

apiVersion: v1
kind: Pod
metadata:
  name: redis-client
  namespace: training
spec:
  containers:
  - name: redis-client
    image: registry.dev.test:5000/mytools:0.0.0
    imagePullPolicy: IfNotPresent
    command:
      - sleep
      - "3600"

Créez le pod:

kubectl create -f pod.redis.client.2.yaml

Accédez au shell du pod:

kubectl exec -n training -it redis-client -- /bin/bash

Connectez vous à la base Redis:

redis-cli -h redis-master.database

Vérifiez si vous avez toujours vos données:

redis-master.database:6379> 
redis-master.database:6379> get firstname
"bob"
redis-master.database:6379> get lastname
"morane"
redis-master.database:6379>

Voilà. 🍾 Maintenant, nous disposons des éléments nécessaires pour pousser plus loin nos expérimentations (donc enfin passer aux MicroServices, sauf si j'ai une nouvelle idée entre temps).

Bonne lecture et bon week-end