redis.yaml

Overview

redis.yaml is a Kubernetes manifest template file designed to deploy and manage a Redis instance within a Kubernetes cluster. It is structured as a Helm template, allowing dynamic configuration through templating directives ({{ ... }}) and values provided during Helm chart installation or upgrade.

This file defines multiple Kubernetes resources essential for running Redis as a StatefulSet with persistence, service discovery, load balancing, and high availability controls:

• Headless Service: Enables stable network identity for Redis pods.

• StatefulSet: Manages the lifecycle of Redis pods with persistent storage and controlled updates.

• Cluster Service: Provides external access to Redis pods through a standard Kubernetes service.

• Pod Disruption Budget (PDB): Ensures availability during node maintenance or voluntary disruptions.

The manifest is tailored to be part of a larger application (likely named "ragflow") and integrates with shared labels, selectors, and environment configurations.

Detailed Resource Descriptions

1. Headless Service

apiVersion: v1
kind: Service
metadata:
  name: {{ include "ragflow.fullname" . }}-redis
  annotations:
    "helm.sh/resource-policy": keep
  labels:
    {{- include "ragflow.labels" . | nindent 4 }}
    app.kubernetes.io/component: redis
spec:
  ports:
    - port: 6379
      name: redis
      protocol: TCP
  clusterIP: None  # Headless service for StatefulSet
  selector:
    {{- include "ragflow.selectorLabels" . | nindent 4 }}
    app.kubernetes.io/component: redis

• Purpose: Creates a headless service (no cluster IP) to provide stable network identities for Redis pods in the StatefulSet. This is crucial for stateful applications needing DNS resolution per pod.

• Key Points:

  • clusterIP: None indicates headless service.

  • Ports expose Redis on default port 6379.

  • Selects pods by shared labels and Redis component label.

  • Annotation "helm.sh/resource-policy": keep ensures this resource is not deleted during Helm uninstall, preserving state.

2. StatefulSet

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: {{ include "ragflow.fullname" . }}-redis
  labels:
    {{- include "ragflow.labels" . | nindent 4 }}
    app.kubernetes.io/component: redis
spec:
  serviceName: {{ include "ragflow.fullname" . }}-redis
  replicas: 1
  selector:
    matchLabels:
      {{- include "ragflow.selectorLabels" . | nindent 6 }}
      app.kubernetes.io/component: redis
  template:
    metadata:
      labels:
        {{- include "ragflow.labels" . | nindent 8 }}
        app.kubernetes.io/component: redis
      annotations:
        checksum/config-env: {{ include (print $.Template.BasePath "/env.yaml") . | sha256sum }}
    spec:
      {{- if or .Values.imagePullSecrets .Values.redis.image.pullSecrets }}
      imagePullSecrets:
        {{- with .Values.imagePullSecrets }}
        {{- toYaml . | nindent 8 }}
        {{- end }}
        {{- with .Values.redis.image.pullSecrets }}
        {{- toYaml . | nindent 8 }}
        {{- end }}
      {{- end }}
      terminationGracePeriodSeconds: 60
      containers:
        - name: redis
          image: {{ .Values.redis.image.repository }}:{{ .Values.redis.image.tag }}
          {{- with .Values.redis.image.pullPolicy }}
          imagePullPolicy: {{ . }}
          {{- end }}
          command:
            - "sh"
            - "-c"
            - "exec redis-server --requirepass ${REDIS_PASSWORD} --maxmemory 128mb --maxmemory-policy allkeys-lru"
          envFrom:
            - secretRef:
                name: {{ include "ragflow.fullname" . }}-env-config
          ports:
            - containerPort: 6379
              name: redis
          {{- if .Values.redis.persistence.enabled }}
          volumeMounts:
            - name: redis-data
              mountPath: /data
          {{- end }}
          {{- with .Values.redis.deployment.resources }}
          resources:
            {{- . | toYaml | nindent 12 }}
          {{- end }}
  {{- if .Values.redis.persistence.enabled }}
  {{- with .Values.redis.persistence.retentionPolicy }}
  persistentVolumeClaimRetentionPolicy:
    {{- with .whenDeleted }}
    whenDeleted: {{ . }}
    {{- end }}
    {{- with .whenScaled }}
    whenScaled: {{ . }}
    {{- end }}
  {{- end }}
  volumeClaimTemplates:
    - metadata:
        name: redis-data
        labels:
          {{- include "ragflow.selectorLabels" . | nindent 10 }}
          app.kubernetes.io/component: redis
      spec:
        accessModes:
          - ReadWriteOnce
        {{- with .Values.redis.storage.className }}
        storageClassName: {{ . }}
        {{- end }}
        resources:
          requests:
            storage: {{ .Values.redis.storage.capacity }}
  {{- end }}

• Purpose: Defines the Redis StatefulSet to deploy Redis pods with stable identities and persistent storage.

• Key Parameters:

  • replicas: Number of Redis pods to run, default is 1; can be scaled.

  • serviceName: Links to the headless service to enable DNS for each pod.

  • selector and template.metadata.labels: Use Helm templated selectors and labels to ensure pods are managed correctly.

  • terminationGracePeriodSeconds: 60 seconds to allow graceful shutdown.

• Container Details:

  • Runs Redis server with command-line options:

    • --requirepass ${REDIS_PASSWORD}: Secures Redis with a password injected via environment variables loaded from a Kubernetes Secret (envFrom.secretRef).

    • --maxmemory 128mb: Limits maximum memory usage.

    • --maxmemory-policy allkeys-lru: Eviction policy for Redis keys.

  • Exposes port 6379.

  • Mounts persistent volume at /data if persistence is enabled.

  • Allows resource requests and limits via .Values.redis.deployment.resources.

• Persistence:

  • Conditional volumeClaimTemplates create PersistentVolumeClaims for Redis data storage.

  • Retention policies (whenDeleted, whenScaled) control PVC lifecycle.

• Image Pull Secrets:

  • Supports specifying image pull secrets from global or Redis-specific values.

Usage example snippet (values.yaml excerpt):

redis:
  image:
    repository: redis
    tag: "7.0"
    pullPolicy: IfNotPresent
  persistence:
    enabled: true
    storage:
      capacity: 1Gi
      className: standard
  deployment:
    resources:
      limits:
        memory: "256Mi"
        cpu: "500m"
      requests:
        memory: "128Mi"
        cpu: "250m"

3. Cluster Service

apiVersion: v1
kind: Service
metadata:
  name: {{ include "ragflow.fullname" . }}-redis-svc
  labels:
    {{- include "ragflow.labels" . | nindent 4 }}
    app.kubernetes.io/component: redis
spec:
  ports:
    - port: 6379
      targetPort: redis
      protocol: TCP
  selector:
    {{- include "ragflow.selectorLabels" . | nindent 4 }}
    app.kubernetes.io/component: redis

• Purpose: Provides a stable service endpoint for clients to access Redis.

• Details:

  • Exposes port 6379.

  • Uses selectors matching Redis pods.

  • Unlike the headless service, this service has a cluster IP and can be used for internal load balancing.

4. Pod Disruption Budget (PDB)

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: {{ include "ragflow.fullname" . }}-redis-pdb
  labels:
    {{- include "ragflow.labels" . | nindent 4 }}
    app.kubernetes.io/component: redis
spec:
  minAvailable: 1
  selector:
    matchLabels:
      {{- include "ragflow.selectorLabels" . | nindent 6 }}
      app.kubernetes.io/component: redis

• Purpose: Ensures at least one Redis pod remains available during voluntary disruptions (e.g., node drains).

• Key Point: minAvailable: 1 guarantees minimum uptime for the Redis service.

Important Implementation Details and Algorithms

• Redis is configured to use password authentication (--requirepass) with the password securely injected via Kubernetes Secrets.

• Memory management uses Redis' allkeys-lru eviction policy, meaning when max memory is reached, least recently used keys are evicted.

• StatefulSet ensures pod identity stability and ordered deployment, critical for stateful workloads like Redis.

• Persistent storage is facilitated with PersistentVolumeClaims and retention policies that control PVC behavior on StatefulSet scaling or deletion.

• The manifest uses Helm template functions extensively for label management, resource naming, and hashing configuration files to trigger pod rollouts when environment changes occur.

• Graceful termination with a 60-second timeout allows Redis to persist data and shutdown cleanly.

Interaction with Other System Components

• The Redis StatefulSet depends on a headless service for DNS and network identity.

• The cluster service exposes Redis internally to other application components (likely the ragflow app), enabling them to connect to Redis on port 6379.

• Environment variables and secrets injected into Redis pods connect this manifest to the overall configuration management system of the application.

• The PDB interacts with the cluster's disruption controller to maintain Redis availability.

• Persistent volumes provisioned here can depend on underlying cloud provider or storage class configurations.

Mermaid Diagram: Kubernetes Resource Structure and Relationships

flowchart TD
    A[Headless Service]
    B[StatefulSet (Redis)]
    C[PersistentVolumeClaim]
    D[Cluster Service]
    E[Pod Disruption Budget]

    A --> B
    B --> C
    D --> B
    E --> B

    classDef resource fill:#f9f,stroke:#333,stroke-width:1px;
    class A,B,C,D,E resource;

• Explanation:

  • Headless Service provides stable network identities for pods in StatefulSet.

  • StatefulSet manages Redis pods and mounts persistent storage via PVC.

  • Cluster Service routes traffic to Redis pods.

  • Pod Disruption Budget protects Redis pods from voluntary downtime.

Summary

The redis.yaml Helm template file is a comprehensive Kubernetes deployment manifest for Redis. It provides a secured, persistent, and highly available Redis service tightly integrated with the application's label and configuration schema. It leverages StatefulSets for stable pod management, persistent volume claims for data durability, and Kubernetes services for seamless networking within the cluster.

This file is a critical part of the overall system architecture, enabling reliable caching or data storage capabilities for the ragflow application.