Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[Bitnami/redis] redis chart 19.6.0 crashed after deployment #27597

Closed
tk2023 opened this issue Jun 29, 2024 · 5 comments
Closed

[Bitnami/redis] redis chart 19.6.0 crashed after deployment #27597

tk2023 opened this issue Jun 29, 2024 · 5 comments
Assignees
@carrodher
Labels
redis solved tech-issues The user has a technical issue about an application triage Triage is needed

Comments

@tk2023
Copy link

tk2023 commented Jun 29, 2024 •
edited by carrodher
Loading

Name and Version

bitnami/redis-19.6.0

What architecture are you using?

amd64

What steps will reproduce the bug?

  1. In digitalocean kubernete environment, install chart redis-19.6.0.
  2. Using standard chart configuration. Just change the redis password to my password.
    here is the pod log:
1:C 29 Jun 2024 14:49:54.787 * oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
1:C 29 Jun 2024 14:49:54.787 * Redis version=7.2.5, bits=64, commit=00000000, modified=0, pid=1, just started
1:C 29 Jun 2024 14:49:54.787 * Configuration loaded
1:M 29 Jun 2024 14:49:54.787 * monotonic clock: POSIX clock_gettime
1:M 29 Jun 2024 14:49:54.788 * Running mode=standalone, port=6379.
1:M 29 Jun 2024 14:49:54.788 * Server initialized
1:M 29 Jun 2024 14:49:54.791 * Reading RDB base file on AOF loading...
1:M 29 Jun 2024 14:49:54.791 * Loading RDB produced by version 7.2.5
1:M 29 Jun 2024 14:49:54.791 * RDB age 469330 seconds
1:M 29 Jun 2024 14:49:54.791 * RDB memory usage when created 634.14 Mb
1:M 29 Jun 2024 14:49:54.791 * RDB is base AOF

here is the description for pod

$ kubectl describe pods redis-master-0  -n redis
Name:             redis-master-0
Namespace:        redis
Priority:         0
Service Account:  redis-master
Node:             pool-sfo-2c-rtng6/10.124.0.5
Start Time:       Sat, 29 Jun 2024 07:38:28 -0700
Labels:           app.kubernetes.io/component=master
                  app.kubernetes.io/instance=redis
                  app.kubernetes.io/managed-by=Helm
                  app.kubernetes.io/name=redis
                  app.kubernetes.io/version=7.2.5
                  apps.kubernetes.io/pod-index=0
                  controller-revision-hash=redis-master-6fb499d86d
                  helm.sh/chart=redis-19.6.0
                  statefulset.kubernetes.io/pod-name=redis-master-0
Annotations:      checksum/configmap: 86bcc953bb473748a3d3dc60b7c11f34e60c93519234d4c37f42e22ada559d47
                  checksum/health: aff24913d801436ea469d8d374b2ddb3ec4c43ee7ab24663d5f8ff1a1b6991a9
                  checksum/scripts: b032d0a9786b34ea89cf23766468aa85a6963199094c6da9b17a186cb2e72c33
                  checksum/secret: 9a0e0ba16140f6403a7f7d3e12489c6ee668f22d156831fcc36f6899478666da
Status:           Running
IP:               10.244.0.58
IPs:
  IP:           10.244.0.58
Controlled By:  StatefulSet/redis-master
Containers:
  redis:
    Container ID:    containerd://8c6b1734363cac6ab2f8dbdb7351491b961134376be31e1b138157afb0644ed7
    Image:           docker.io/bitnami/redis:7.2.5-debian-12-r0
    Image ID:        docker.io/bitnami/redis@sha256:5261cae9e4076b75d114e6bb032a0699c50b004ea06a680a5304c4c08d286adb
    Port:            6379/TCP
    Host Port:       0/TCP
    SeccompProfile:  RuntimeDefault
    Command:
      /bin/bash
    Args:
      -c
      /opt/bitnami/scripts/start-scripts/start-master.sh
    State:          Waiting
      Reason:       CrashLoopBackOff
    Last State:     Terminated
      Reason:       OOMKilled
      Exit Code:    137
      Started:      Sat, 29 Jun 2024 07:49:54 -0700
      Finished:     Sat, 29 Jun 2024 07:49:59 -0700
    Ready:          False
    Restart Count:  7
    Limits:
      cpu:                150m
      ephemeral-storage:  1Gi
      memory:             192Mi
    Requests:
      cpu:                100m
      ephemeral-storage:  50Mi
      memory:             128Mi
    Liveness:             exec [sh -c /health/ping_liveness_local.sh 5] delay=20s timeout=6s period=5s #success=1 #failure=5
    Readiness:            exec [sh -c /health/ping_readiness_local.sh 1] delay=20s timeout=2s period=5s #success=1 #failure=5
    Environment:
      BITNAMI_DEBUG:           false
      REDIS_REPLICATION_MODE:  master
      ALLOW_EMPTY_PASSWORD:    no
      REDIS_PASSWORD:          <set to the key 'redis-password' in secret 'redis'>  Optional: false
      REDIS_TLS_ENABLED:       no
      REDIS_PORT:              6379
    Mounts:
      /data from redis-data (rw)
      /health from health (rw)
      /opt/bitnami/redis/etc/ from empty-dir (rw,path="app-conf-dir")
      /opt/bitnami/redis/mounted-etc from config (rw)
      /opt/bitnami/scripts/start-scripts from start-scripts (rw)
      /tmp from empty-dir (rw,path="tmp-dir")
Conditions:
  Type                        Status
  PodReadyToStartContainers   True
  Initialized                 True
  Ready                       False
  ContainersReady             False
  PodScheduled                True
Volumes:
  redis-data:
    Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:  redis-data-redis-master-0
    ReadOnly:   false
  start-scripts:
    Type:      ConfigMap (a volume populated by a ConfigMap)
    Name:      redis-scripts
    Optional:  false
  health:
    Type:      ConfigMap (a volume populated by a ConfigMap)
    Name:      redis-health
    Optional:  false
  config:
    Type:      ConfigMap (a volume populated by a ConfigMap)
    Name:      redis-configuration
    Optional:  false
  empty-dir:
    Type:        EmptyDir (a temporary directory that shares a pod's lifetime)
    Medium:
    SizeLimit:   <unset>
QoS Class:       Burstable
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type     Reason                  Age                   From                     Message
  ----     ------                  ----                  ----                     -------
  Normal   Scheduled               14m                   default-scheduler        Successfully assigned redis/redis-master-0 to pool-sfo-2c-rtng6
  Normal   SuccessfulAttachVolume  14m                   attachdetach-controller  AttachVolume.Attach succeeded for volume "pvc-fe96e623-8849-4e3a-a499-2b2e5ceb4923"
  Normal   Pulled                  12m (x5 over 14m)     kubelet                  Container image "docker.io/bitnami/redis:7.2.5-debian-12-r0" already present on machine
  Normal   Created                 12m (x5 over 14m)     kubelet                  Created container redis
  Normal   Started                 12m (x5 over 14m)     kubelet                  Started container redis
  Warning  BackOff                 4m12s (x49 over 14m)  kubelet                  Back-off restarting failed container redis in pod redis-master-0_redis(fe32421e-cd1a-4a80-80bb-df5a74da6f6c)

Are you using any custom parameters or values?

The changes are this line:

  password: "password"

and

    replicaCount: 1

What is the expected behavior?

redis should started

What do you see instead?

$ kubectl get pods -n redis
NAME               READY   STATUS             RESTARTS        AGE
redis-master-0     0/1     CrashLoopBackOff   8 (87s ago)     18m
redis-replicas-0   0/1     CrashLoopBackOff   9 (2m21s ago)   19m
@tk2023 tk2023 added the tech-issues The user has a technical issue about an application label Jun 29, 2024
@github-actions github-actions bot added the triage Triage is needed label Jun 29, 2024
@tk2023
Copy link
Author

tk2023 commented Jun 29, 2024 •
edited by carrodher
Loading 

$ helm get all redis -n redis
NAME: redis
LAST DEPLOYED: Sat Jun 29 14:37:16 2024
NAMESPACE: redis
STATUS: deployed
REVISION: 1
CHART: redis
VERSION: 19.6.0
APP_VERSION: 7.2.5
TEST SUITE: None
USER-SUPPLIED VALUES:
architecture: replication
auth:
  enabled: true
  existingSecret: ""
  existingSecretPasswordKey: ""
  password: password
  sentinel: true
  usePasswordFileFromSecret: true
  usePasswordFiles: false
clusterDomain: cluster.local
commonAnnotations: {}
commonConfiguration: |-
  # Enable AOF https://redis.io/topics/persistence#append-only-file
  appendonly yes
  # Disable RDB persistence, AOF persistence already enabled.
  save ""
commonLabels: {}
diagnosticMode:
  args:
  - infinity
  command:
  - sleep
  enabled: false
existingConfigmap: ""
extraDeploy: []
fullnameOverride: ""
global:
  compatibility:
    openshift:
      adaptSecurityContext: auto
  imagePullSecrets: []
  imageRegistry: ""
  redis:
    password: ""
  storageClass: ""
image:
  debug: false
  digest: ""
  pullPolicy: IfNotPresent
  pullSecrets: []
  registry: docker.io
  repository: bitnami/redis
  tag: 7.2.5-debian-12-r0
kubeVersion: ""
kubectl:
  command:
  - /opt/bitnami/scripts/kubectl-scripts/update-master-label.sh
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  image:
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/kubectl
    tag: 1.30.2-debian-12-r0
  resources:
    limits: {}
    requests: {}
master:
  affinity: {}
  args: []
  automountServiceAccountToken: false
  command: []
  configuration: ""
  containerPorts:
    redis: 6379
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  count: 1
  customLivenessProbe: {}
  customReadinessProbe: {}
  customStartupProbe: {}
  disableCommands:
  - FLUSHDB
  - FLUSHALL
  dnsConfig: {}
  dnsPolicy: ""
  enableServiceLinks: true
  extraEnvVars: []
  extraEnvVarsCM: ""
  extraEnvVarsSecret: ""
  extraFlags: []
  extraVolumeMounts: []
  extraVolumes: []
  hostAliases: []
  initContainers: []
  kind: StatefulSet
  lifecycleHooks: {}
  livenessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 5
  minReadySeconds: 0
  nodeAffinityPreset:
    key: ""
    type: ""
    values: []
  nodeSelector: {}
  pdb:
    create: true
    maxUnavailable: ""
    minAvailable: ""
  persistence:
    accessModes:
    - ReadWriteOnce
    annotations: {}
    dataSource: {}
    enabled: true
    existingClaim: ""
    labels: {}
    medium: ""
    path: /data
    selector: {}
    size: 8Gi
    sizeLimit: ""
    storageClass: ""
    subPath: ""
    subPathExpr: ""
  persistentVolumeClaimRetentionPolicy:
    enabled: false
    whenDeleted: Retain
    whenScaled: Retain
  podAffinityPreset: ""
  podAnnotations: {}
  podAntiAffinityPreset: soft
  podLabels: {}
  podSecurityContext:
    enabled: true
    fsGroup: 1001
    fsGroupChangePolicy: Always
    supplementalGroups: []
    sysctls: []
  preExecCmds: []
  priorityClassName: ""
  readinessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 1
  resources: {}
  resourcesPreset: nano
  revisionHistoryLimit: 10
  schedulerName: ""
  service:
    annotations: {}
    clusterIP: ""
    externalIPs: []
    externalTrafficPolicy: Cluster
    extraPorts: []
    internalTrafficPolicy: Cluster
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    nodePorts:
      redis: ""
    portNames:
      redis: tcp-redis
    ports:
      redis: 6379
    sessionAffinity: None
    sessionAffinityConfig: {}
    type: ClusterIP
  serviceAccount:
    annotations: {}
    automountServiceAccountToken: false
    create: true
    name: ""
  shareProcessNamespace: false
  sidecars: []
  startupProbe:
    enabled: false
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 5
  terminationGracePeriodSeconds: 30
  tolerations: []
  topologySpreadConstraints: []
  updateStrategy:
    type: RollingUpdate
metrics:
  command: []
  containerPorts:
    http: 9121
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  customLivenessProbe: {}
  customReadinessProbe: {}
  customStartupProbe: {}
  enabled: false
  extraArgs: {}
  extraEnvVars: []
  extraVolumeMounts: []
  extraVolumes: []
  image:
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/redis-exporter
    tag: 1.61.0-debian-12-r0
  livenessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 10
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
  podAnnotations:
    prometheus.io/port: "9121"
    prometheus.io/scrape: "true"
  podLabels: {}
  podMonitor:
    additionalEndpoints: []
    additionalLabels: {}
    enabled: false
    honorLabels: false
    interval: 30s
    metricRelabelings: []
    namespace: ""
    podTargetLabels: []
    port: metrics
    relabelings: []
    relabellings: []
    sampleLimit: false
    scrapeTimeout: ""
    targetLimit: false
  prometheusRule:
    additionalLabels: {}
    enabled: false
    namespace: ""
    rules: []
  readinessProbe:
    enabled: true
    failureThreshold: 3
    initialDelaySeconds: 5
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 1
  redisTargetHost: localhost
  resources: {}
  resourcesPreset: nano
  service:
    annotations: {}
    clusterIP: ""
    enabled: true
    externalTrafficPolicy: Cluster
    extraPorts: []
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    ports:
      http: 9121
    type: ClusterIP
  serviceMonitor:
    additionalEndpoints: []
    additionalLabels: {}
    enabled: false
    honorLabels: false
    interval: 30s
    metricRelabelings: []
    namespace: ""
    podTargetLabels: []
    port: http-metrics
    relabelings: []
    relabellings: []
    sampleLimit: false
    scrapeTimeout: ""
    targetLimit: false
  startupProbe:
    enabled: false
    failureThreshold: 5
    initialDelaySeconds: 10
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
nameOverride: ""
nameResolutionThreshold: 5
nameResolutionTimeout: 5
namespaceOverride: ""
networkPolicy:
  allowExternal: true
  allowExternalEgress: true
  enabled: true
  extraEgress: []
  extraIngress: []
  ingressNSMatchLabels: {}
  ingressNSPodMatchLabels: {}
  metrics:
    allowExternal: true
    ingressNSMatchLabels: {}
    ingressNSPodMatchLabels: {}
pdb: {}
podSecurityPolicy:
  create: false
  enabled: false
rbac:
  create: false
  rules: []
replica:
  affinity: {}
  args: []
  automountServiceAccountToken: false
  autoscaling:
    enabled: false
    maxReplicas: 11
    minReplicas: 1
    targetCPU: ""
    targetMemory: ""
  command: []
  configuration: ""
  containerPorts:
    redis: 6379
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  customLivenessProbe: {}
  customReadinessProbe: {}
  customStartupProbe: {}
  disableCommands:
  - FLUSHDB
  - FLUSHALL
  dnsConfig: {}
  dnsPolicy: ""
  enableServiceLinks: true
  externalMaster:
    enabled: false
    host: ""
    port: 6379
  extraEnvVars: []
  extraEnvVarsCM: ""
  extraEnvVarsSecret: ""
  extraFlags: []
  extraVolumeMounts: []
  extraVolumes: []
  hostAliases: []
  initContainers: []
  kind: StatefulSet
  lifecycleHooks: {}
  livenessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 5
  minReadySeconds: 0
  nodeAffinityPreset:
    key: ""
    type: ""
    values: []
  nodeSelector: {}
  pdb:
    create: true
    maxUnavailable: ""
    minAvailable: ""
  persistence:
    accessModes:
    - ReadWriteOnce
    annotations: {}
    dataSource: {}
    enabled: true
    existingClaim: ""
    labels: {}
    medium: ""
    path: /data
    selector: {}
    size: 8Gi
    sizeLimit: ""
    storageClass: ""
    subPath: ""
    subPathExpr: ""
  persistentVolumeClaimRetentionPolicy:
    enabled: false
    whenDeleted: Retain
    whenScaled: Retain
  podAffinityPreset: ""
  podAnnotations: {}
  podAntiAffinityPreset: soft
  podLabels: {}
  podManagementPolicy: ""
  podSecurityContext:
    enabled: true
    fsGroup: 1001
    fsGroupChangePolicy: Always
    supplementalGroups: []
    sysctls: []
  preExecCmds: []
  priorityClassName: ""
  readinessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 1
  replicaCount: 1
  resources: {}
  resourcesPreset: nano
  revisionHistoryLimit: 10
  schedulerName: ""
  service:
    annotations: {}
    clusterIP: ""
    externalTrafficPolicy: Cluster
    extraPorts: []
    internalTrafficPolicy: Cluster
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    nodePorts:
      redis: ""
    ports:
      redis: 6379
    sessionAffinity: None
    sessionAffinityConfig: {}
    type: ClusterIP
  serviceAccount:
    annotations: {}
    automountServiceAccountToken: false
    create: true
    name: ""
  shareProcessNamespace: false
  sidecars: []
  startupProbe:
    enabled: true
    failureThreshold: 22
    initialDelaySeconds: 10
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
  terminationGracePeriodSeconds: 30
  tolerations: []
  topologySpreadConstraints: []
  updateStrategy:
    type: RollingUpdate
secretAnnotations: {}
sentinel:
  annotations: {}
  args: []
  automateClusterRecovery: false
  command: []
  configuration: ""
  containerPorts:
    sentinel: 26379
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  customLivenessProbe: {}
  customReadinessProbe: {}
  customStartupProbe: {}
  downAfterMilliseconds: 60000
  enableServiceLinks: true
  enabled: false
  externalMaster:
    enabled: false
    host: ""
    port: 6379
  extraEnvVars: []
  extraEnvVarsCM: ""
  extraEnvVarsSecret: ""
  extraVolumeMounts: []
  extraVolumes: []
  failoverTimeout: 180000
  getMasterTimeout: 90
  image:
    debug: false
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/redis-sentinel
    tag: 7.2.5-debian-12-r0
  lifecycleHooks: {}
  livenessProbe:
    enabled: true
    failureThreshold: 6
    initialDelaySeconds: 20
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
  masterService:
    annotations: {}
    clusterIP: ""
    enabled: false
    externalTrafficPolicy: ""
    extraPorts: []
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    nodePorts:
      redis: ""
    ports:
      redis: 6379
    sessionAffinity: None
    sessionAffinityConfig: {}
    type: ClusterIP
  masterSet: mymaster
  parallelSyncs: 1
  persistence:
    accessModes:
    - ReadWriteOnce
    annotations: {}
    dataSource: {}
    enabled: false
    labels: {}
    medium: ""
    selector: {}
    size: 100Mi
    sizeLimit: ""
    storageClass: ""
  persistentVolumeClaimRetentionPolicy:
    enabled: false
    whenDeleted: Retain
    whenScaled: Retain
  preExecCmds: []
  quorum: 2
  readinessProbe:
    enabled: true
    failureThreshold: 6
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 1
  redisShutdownWaitFailover: true
  resources: {}
  resourcesPreset: nano
  service:
    annotations: {}
    clusterIP: ""
    createMaster: false
    externalTrafficPolicy: Cluster
    extraPorts: []
    headless:
      annotations: {}
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    nodePorts:
      redis: ""
      sentinel: ""
    ports:
      redis: 6379
      sentinel: 26379
    sessionAffinity: None
    sessionAffinityConfig: {}
    type: ClusterIP
  startupProbe:
    enabled: true
    failureThreshold: 22
    initialDelaySeconds: 10
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
  terminationGracePeriodSeconds: 30
serviceAccount:
  annotations: {}
  automountServiceAccountToken: false
  create: true
  name: ""
serviceBindings:
  enabled: false
sysctl:
  command: []
  enabled: false
  image:
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/os-shell
    tag: 12-debian-12-r22
  mountHostSys: false
  resources: {}
  resourcesPreset: nano
tls:
  authClients: true
  autoGenerated: false
  certCAFilename: ""
  certFilename: ""
  certKeyFilename: ""
  certificatesSecret: ""
  dhParamsFilename: ""
  enabled: false
  existingSecret: ""
useExternalDNS:
  additionalAnnotations: {}
  annotationKey: external-dns.alpha.kubernetes.io/
  enabled: false
  suffix: ""
useHostnames: true
volumePermissions:
  containerSecurityContext:
    runAsUser: 0
    seLinuxOptions: {}
  enabled: false
  image:
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/os-shell
    tag: 12-debian-12-r22
  resources: {}
  resourcesPreset: nano

COMPUTED VALUES:
architecture: replication
auth:
  enabled: true
  existingSecret: ""
  existingSecretPasswordKey: ""
  password: password
  sentinel: true
  usePasswordFileFromSecret: true
  usePasswordFiles: false
clusterDomain: cluster.local
common:
  exampleValue: common-chart
  global:
    compatibility:
      openshift:
        adaptSecurityContext: auto
    imagePullSecrets: []
    imageRegistry: ""
    redis:
      password: ""
    storageClass: ""
commonAnnotations: {}
commonConfiguration: |-
  # Enable AOF https://redis.io/topics/persistence#append-only-file
  appendonly yes
  # Disable RDB persistence, AOF persistence already enabled.
  save ""
commonLabels: {}
diagnosticMode:
  args:
  - infinity
  command:
  - sleep
  enabled: false
existingConfigmap: ""
extraDeploy: []
fullnameOverride: ""
global:
  compatibility:
    openshift:
      adaptSecurityContext: auto
  imagePullSecrets: []
  imageRegistry: ""
  redis:
    password: ""
  storageClass: ""
image:
  debug: false
  digest: ""
  pullPolicy: IfNotPresent
  pullSecrets: []
  registry: docker.io
  repository: bitnami/redis
  tag: 7.2.5-debian-12-r0
kubeVersion: ""
kubectl:
  command:
  - /opt/bitnami/scripts/kubectl-scripts/update-master-label.sh
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  image:
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/kubectl
    tag: 1.30.2-debian-12-r0
  resources:
    limits: {}
    requests: {}
master:
  affinity: {}
  args: []
  automountServiceAccountToken: false
  command: []
  configuration: ""
  containerPorts:
    redis: 6379
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  count: 1
  customLivenessProbe: {}
  customReadinessProbe: {}
  customStartupProbe: {}
  disableCommands:
  - FLUSHDB
  - FLUSHALL
  dnsConfig: {}
  dnsPolicy: ""
  enableServiceLinks: true
  extraEnvVars: []
  extraEnvVarsCM: ""
  extraEnvVarsSecret: ""
  extraFlags: []
  extraVolumeMounts: []
  extraVolumes: []
  hostAliases: []
  initContainers: []
  kind: StatefulSet
  lifecycleHooks: {}
  livenessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 5
  minReadySeconds: 0
  nodeAffinityPreset:
    key: ""
    type: ""
    values: []
  nodeSelector: {}
  pdb:
    create: true
    maxUnavailable: ""
    minAvailable: ""
  persistence:
    accessModes:
    - ReadWriteOnce
    annotations: {}
    dataSource: {}
    enabled: true
    existingClaim: ""
    labels: {}
    medium: ""
    path: /data
    selector: {}
    size: 8Gi
    sizeLimit: ""
    storageClass: ""
    subPath: ""
    subPathExpr: ""
  persistentVolumeClaimRetentionPolicy:
    enabled: false
    whenDeleted: Retain
    whenScaled: Retain
  podAffinityPreset: ""
  podAnnotations: {}
  podAntiAffinityPreset: soft
  podLabels: {}
  podSecurityContext:
    enabled: true
    fsGroup: 1001
    fsGroupChangePolicy: Always
    supplementalGroups: []
    sysctls: []
  preExecCmds: []
  priorityClassName: ""
  readinessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 1
  resources: {}
  resourcesPreset: nano
  revisionHistoryLimit: 10
  schedulerName: ""
  service:
    annotations: {}
    clusterIP: ""
    externalIPs: []
    externalTrafficPolicy: Cluster
    extraPorts: []
    internalTrafficPolicy: Cluster
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    nodePorts:
      redis: ""
    portNames:
      redis: tcp-redis
    ports:
      redis: 6379
    sessionAffinity: None
    sessionAffinityConfig: {}
    type: ClusterIP
  serviceAccount:
    annotations: {}
    automountServiceAccountToken: false
    create: true
    name: ""
  shareProcessNamespace: false
  sidecars: []
  startupProbe:
    enabled: false
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 5
  terminationGracePeriodSeconds: 30
  tolerations: []
  topologySpreadConstraints: []
  updateStrategy:
    type: RollingUpdate
metrics:
  command: []
  containerPorts:
    http: 9121
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  customLivenessProbe: {}
  customReadinessProbe: {}
  customStartupProbe: {}
  enabled: false
  extraArgs: {}
  extraEnvVars: []
  extraVolumeMounts: []
  extraVolumes: []
  image:
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/redis-exporter
    tag: 1.61.0-debian-12-r0
  livenessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 10
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
  podAnnotations:
    prometheus.io/port: "9121"
    prometheus.io/scrape: "true"
  podLabels: {}
  podMonitor:
    additionalEndpoints: []
    additionalLabels: {}
    enabled: false
    honorLabels: false
    interval: 30s
    metricRelabelings: []
    namespace: ""
    podTargetLabels: []
    port: metrics
    relabelings: []
    relabellings: []
    sampleLimit: false
    scrapeTimeout: ""
    targetLimit: false
  prometheusRule:
    additionalLabels: {}
    enabled: false
    namespace: ""
    rules: []
  readinessProbe:
    enabled: true
    failureThreshold: 3
    initialDelaySeconds: 5
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 1
  redisTargetHost: localhost
  resources: {}
  resourcesPreset: nano
  service:
    annotations: {}
    clusterIP: ""
    enabled: true
    externalTrafficPolicy: Cluster
    extraPorts: []
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    ports:
      http: 9121
    type: ClusterIP
  serviceMonitor:
    additionalEndpoints: []
    additionalLabels: {}
    enabled: false
    honorLabels: false
    interval: 30s
    metricRelabelings: []
    namespace: ""
    podTargetLabels: []
    port: http-metrics
    relabelings: []
    relabellings: []
    sampleLimit: false
    scrapeTimeout: ""
    targetLimit: false
  startupProbe:
    enabled: false
    failureThreshold: 5
    initialDelaySeconds: 10
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
nameOverride: ""
nameResolutionThreshold: 5
nameResolutionTimeout: 5
namespaceOverride: ""
networkPolicy:
  allowExternal: true
  allowExternalEgress: true
  enabled: true
  extraEgress: []
  extraIngress: []
  ingressNSMatchLabels: {}
  ingressNSPodMatchLabels: {}
  metrics:
    allowExternal: true
    ingressNSMatchLabels: {}
    ingressNSPodMatchLabels: {}
pdb: {}
podSecurityPolicy:
  create: false
  enabled: false
rbac:
  create: false
  rules: []
replica:
  affinity: {}
  args: []
  automountServiceAccountToken: false
  autoscaling:
    enabled: false
    maxReplicas: 11
    minReplicas: 1
    targetCPU: ""
    targetMemory: ""
  command: []
  configuration: ""
  containerPorts:
    redis: 6379
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  customLivenessProbe: {}
  customReadinessProbe: {}
  customStartupProbe: {}
  disableCommands:
  - FLUSHDB
  - FLUSHALL
  dnsConfig: {}
  dnsPolicy: ""
  enableServiceLinks: true
  externalMaster:
    enabled: false
    host: ""
    port: 6379
  extraEnvVars: []
  extraEnvVarsCM: ""
  extraEnvVarsSecret: ""
  extraFlags: []
  extraVolumeMounts: []
  extraVolumes: []
  hostAliases: []
  initContainers: []
  kind: StatefulSet
  lifecycleHooks: {}
  livenessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 5
  minReadySeconds: 0
  nodeAffinityPreset:
    key: ""
    type: ""
    values: []
  nodeSelector: {}
  pdb:
    create: true
    maxUnavailable: ""
    minAvailable: ""
  persistence:
    accessModes:
    - ReadWriteOnce
    annotations: {}
    dataSource: {}
    enabled: true
    existingClaim: ""
    labels: {}
    medium: ""
    path: /data
    selector: {}
    size: 8Gi
    sizeLimit: ""
    storageClass: ""
    subPath: ""
    subPathExpr: ""
  persistentVolumeClaimRetentionPolicy:
    enabled: false
    whenDeleted: Retain
    whenScaled: Retain
  podAffinityPreset: ""
  podAnnotations: {}
  podAntiAffinityPreset: soft
  podLabels: {}
  podManagementPolicy: ""
  podSecurityContext:
    enabled: true
    fsGroup: 1001
    fsGroupChangePolicy: Always
    supplementalGroups: []
    sysctls: []
  preExecCmds: []
  priorityClassName: ""
  readinessProbe:
    enabled: true
    failureThreshold: 5
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 1
  replicaCount: 1
  resources: {}
  resourcesPreset: nano
  revisionHistoryLimit: 10
  schedulerName: ""
  service:
    annotations: {}
    clusterIP: ""
    externalTrafficPolicy: Cluster
    extraPorts: []
    internalTrafficPolicy: Cluster
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    nodePorts:
      redis: ""
    ports:
      redis: 6379
    sessionAffinity: None
    sessionAffinityConfig: {}
    type: ClusterIP
  serviceAccount:
    annotations: {}
    automountServiceAccountToken: false
    create: true
    name: ""
  shareProcessNamespace: false
  sidecars: []
  startupProbe:
    enabled: true
    failureThreshold: 22
    initialDelaySeconds: 10
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
  terminationGracePeriodSeconds: 30
  tolerations: []
  topologySpreadConstraints: []
  updateStrategy:
    type: RollingUpdate
secretAnnotations: {}
sentinel:
  annotations: {}
  args: []
  automateClusterRecovery: false
  command: []
  configuration: ""
  containerPorts:
    sentinel: 26379
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    enabled: true
    readOnlyRootFilesystem: true
    runAsGroup: 1001
    runAsNonRoot: true
    runAsUser: 1001
    seLinuxOptions: {}
    seccompProfile:
      type: RuntimeDefault
  customLivenessProbe: {}
  customReadinessProbe: {}
  customStartupProbe: {}
  downAfterMilliseconds: 60000
  enableServiceLinks: true
  enabled: false
  externalMaster:
    enabled: false
    host: ""
    port: 6379
  extraEnvVars: []
  extraEnvVarsCM: ""
  extraEnvVarsSecret: ""
  extraVolumeMounts: []
  extraVolumes: []
  failoverTimeout: 180000
  getMasterTimeout: 90
  image:
    debug: false
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/redis-sentinel
    tag: 7.2.5-debian-12-r0
  lifecycleHooks: {}
  livenessProbe:
    enabled: true
    failureThreshold: 6
    initialDelaySeconds: 20
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
  masterService:
    annotations: {}
    clusterIP: ""
    enabled: false
    externalTrafficPolicy: ""
    extraPorts: []
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    nodePorts:
      redis: ""
    ports:
      redis: 6379
    sessionAffinity: None
    sessionAffinityConfig: {}
    type: ClusterIP
  masterSet: mymaster
  parallelSyncs: 1
  persistence:
    accessModes:
    - ReadWriteOnce
    annotations: {}
    dataSource: {}
    enabled: false
    labels: {}
    medium: ""
    selector: {}
    size: 100Mi
    sizeLimit: ""
    storageClass: ""
  persistentVolumeClaimRetentionPolicy:
    enabled: false
    whenDeleted: Retain
    whenScaled: Retain
  preExecCmds: []
  quorum: 2
  readinessProbe:
    enabled: true
    failureThreshold: 6
    initialDelaySeconds: 20
    periodSeconds: 5
    successThreshold: 1
    timeoutSeconds: 1
  redisShutdownWaitFailover: true
  resources: {}
  resourcesPreset: nano
  service:
    annotations: {}
    clusterIP: ""
    createMaster: false
    externalTrafficPolicy: Cluster
    extraPorts: []
    headless:
      annotations: {}
    loadBalancerClass: ""
    loadBalancerIP: ""
    loadBalancerSourceRanges: []
    nodePorts:
      redis: ""
      sentinel: ""
    ports:
      redis: 6379
      sentinel: 26379
    sessionAffinity: None
    sessionAffinityConfig: {}
    type: ClusterIP
  startupProbe:
    enabled: true
    failureThreshold: 22
    initialDelaySeconds: 10
    periodSeconds: 10
    successThreshold: 1
    timeoutSeconds: 5
  terminationGracePeriodSeconds: 30
serviceAccount:
  annotations: {}
  automountServiceAccountToken: false
  create: true
  name: ""
serviceBindings:
  enabled: false
sysctl:
  command: []
  enabled: false
  image:
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/os-shell
    tag: 12-debian-12-r22
  mountHostSys: false
  resources: {}
  resourcesPreset: nano
tls:
  authClients: true
  autoGenerated: false
  certCAFilename: ""
  certFilename: ""
  certKeyFilename: ""
  certificatesSecret: ""
  dhParamsFilename: ""
  enabled: false
  existingSecret: ""
useExternalDNS:
  additionalAnnotations: {}
  annotationKey: external-dns.alpha.kubernetes.io/
  enabled: false
  suffix: ""
useHostnames: true
volumePermissions:
  containerSecurityContext:
    runAsUser: 0
    seLinuxOptions: {}
  enabled: false
  image:
    digest: ""
    pullPolicy: IfNotPresent
    pullSecrets: []
    registry: docker.io
    repository: bitnami/os-shell
    tag: 12-debian-12-r22
  resources: {}
  resourcesPreset: nano

HOOKS:
MANIFEST:
---
# Source: redis/templates/networkpolicy.yaml
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: redis
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
spec:
  podSelector:
    matchLabels:
      app.kubernetes.io/instance: redis
      app.kubernetes.io/name: redis
  policyTypes:
    - Ingress
    - Egress
  egress:
    - {}
  ingress:
    # Allow inbound connections
    - ports:
        - port: 6379
---
# Source: redis/templates/master/pdb.yaml
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: redis-master
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
    app.kubernetes.io/component: master
spec:
  maxUnavailable: 1
  selector:
    matchLabels:
      app.kubernetes.io/instance: redis
      app.kubernetes.io/name: redis
      app.kubernetes.io/component: master
---
# Source: redis/templates/replicas/pdb.yaml
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: redis-replicas
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
    app.kubernetes.io/component: replica
spec:
  maxUnavailable: 1
  selector:
    matchLabels:
      app.kubernetes.io/instance: redis
      app.kubernetes.io/name: redis
      app.kubernetes.io/component: replica
---
# Source: redis/templates/master/serviceaccount.yaml
apiVersion: v1
kind: ServiceAccount
automountServiceAccountToken: false
metadata:
  name: redis-master
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
---
# Source: redis/templates/replicas/serviceaccount.yaml
apiVersion: v1
kind: ServiceAccount
automountServiceAccountToken: false
metadata:
  name: redis-replica
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
---
# Source: redis/templates/secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: redis
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
type: Opaque
data:
  redis-password: "ZXJoODdLN1F3MjRmZVY3RQ=="
---
# Source: redis/templates/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: redis-configuration
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
data:
  redis.conf: |-
    # User-supplied common configuration:
    # Enable AOF https://redis.io/topics/persistence#append-only-file
    appendonly yes
    # Disable RDB persistence, AOF persistence already enabled.
    save ""
    # End of common configuration
  master.conf: |-
    dir /data
    # User-supplied master configuration:
    rename-command FLUSHDB ""
    rename-command FLUSHALL ""
    # End of master configuration
  replica.conf: |-
    dir /data
    # User-supplied replica configuration:
    rename-command FLUSHDB ""
    rename-command FLUSHALL ""
    # End of replica configuration
---
# Source: redis/templates/health-configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: redis-health
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
data:
  ping_readiness_local.sh: |-
    #!/bin/bash

    [[ -f $REDIS_PASSWORD_FILE ]] && export REDIS_PASSWORD="$(< "${REDIS_PASSWORD_FILE}")"
    [[ -n "$REDIS_PASSWORD" ]] && export REDISCLI_AUTH="$REDIS_PASSWORD"
    response=$(
      timeout -s 15 $1 \
      redis-cli \
        -h localhost \
        -p $REDIS_PORT \
        ping
    )
    if [ "$?" -eq "124" ]; then
      echo "Timed out"
      exit 1
    fi
    if [ "$response" != "PONG" ]; then
      echo "$response"
      exit 1
    fi
  ping_liveness_local.sh: |-
    #!/bin/bash

    [[ -f $REDIS_PASSWORD_FILE ]] && export REDIS_PASSWORD="$(< "${REDIS_PASSWORD_FILE}")"
    [[ -n "$REDIS_PASSWORD" ]] && export REDISCLI_AUTH="$REDIS_PASSWORD"
    response=$(
      timeout -s 15 $1 \
      redis-cli \
        -h localhost \
        -p $REDIS_PORT \
        ping
    )
    if [ "$?" -eq "124" ]; then
      echo "Timed out"
      exit 1
    fi
    responseFirstWord=$(echo $response | head -n1 | awk '{print $1;}')
    if [ "$response" != "PONG" ] && [ "$responseFirstWord" != "LOADING" ] && [ "$responseFirstWord" != "MASTERDOWN" ]; then
      echo "$response"
      exit 1
    fi
  ping_readiness_master.sh: |-
    #!/bin/bash

    [[ -f $REDIS_MASTER_PASSWORD_FILE ]] && export REDIS_MASTER_PASSWORD="$(< "${REDIS_MASTER_PASSWORD_FILE}")"
    [[ -n "$REDIS_MASTER_PASSWORD" ]] && export REDISCLI_AUTH="$REDIS_MASTER_PASSWORD"
    response=$(
      timeout -s 15 $1 \
      redis-cli \
        -h $REDIS_MASTER_HOST \
        -p $REDIS_MASTER_PORT_NUMBER \
        ping
    )
    if [ "$?" -eq "124" ]; then
      echo "Timed out"
      exit 1
    fi
    if [ "$response" != "PONG" ]; then
      echo "$response"
      exit 1
    fi
  ping_liveness_master.sh: |-
    #!/bin/bash

    [[ -f $REDIS_MASTER_PASSWORD_FILE ]] && export REDIS_MASTER_PASSWORD="$(< "${REDIS_MASTER_PASSWORD_FILE}")"
    [[ -n "$REDIS_MASTER_PASSWORD" ]] && export REDISCLI_AUTH="$REDIS_MASTER_PASSWORD"
    response=$(
      timeout -s 15 $1 \
      redis-cli \
        -h $REDIS_MASTER_HOST \
        -p $REDIS_MASTER_PORT_NUMBER \
        ping
    )
    if [ "$?" -eq "124" ]; then
      echo "Timed out"
      exit 1
    fi
    responseFirstWord=$(echo $response | head -n1 | awk '{print $1;}')
    if [ "$response" != "PONG" ] && [ "$responseFirstWord" != "LOADING" ]; then
      echo "$response"
      exit 1
    fi
  ping_readiness_local_and_master.sh: |-
    script_dir="$(dirname "$0")"
    exit_status=0
    "$script_dir/ping_readiness_local.sh" $1 || exit_status=$?
    "$script_dir/ping_readiness_master.sh" $1 || exit_status=$?
    exit $exit_status
  ping_liveness_local_and_master.sh: |-
    script_dir="$(dirname "$0")"
    exit_status=0
    "$script_dir/ping_liveness_local.sh" $1 || exit_status=$?
    "$script_dir/ping_liveness_master.sh" $1 || exit_status=$?
    exit $exit_status
---
# Source: redis/templates/scripts-configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: redis-scripts
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
data:
  start-master.sh: |
    #!/bin/bash

    [[ -f $REDIS_PASSWORD_FILE ]] && export REDIS_PASSWORD="$(< "${REDIS_PASSWORD_FILE}")"
    if [[ -f /opt/bitnami/redis/mounted-etc/master.conf ]];then
        cp /opt/bitnami/redis/mounted-etc/master.conf /opt/bitnami/redis/etc/master.conf
    fi
    if [[ -f /opt/bitnami/redis/mounted-etc/redis.conf ]];then
        cp /opt/bitnami/redis/mounted-etc/redis.conf /opt/bitnami/redis/etc/redis.conf
    fi
    ARGS=("--port" "${REDIS_PORT}")
    ARGS+=("--requirepass" "${REDIS_PASSWORD}")
    ARGS+=("--masterauth" "${REDIS_PASSWORD}")
    ARGS+=("--include" "/opt/bitnami/redis/etc/redis.conf")
    ARGS+=("--include" "/opt/bitnami/redis/etc/master.conf")
    exec redis-server "${ARGS[@]}"
  start-replica.sh: |
    #!/bin/bash

    get_port() {
        hostname="$1"
        type="$2"

        port_var=$(echo "${hostname^^}_SERVICE_PORT_$type" | sed "s/-/_/g")
        port=${!port_var}

        if [ -z "$port" ]; then
            case $type in
                "SENTINEL")
                    echo 26379
                    ;;
                "REDIS")
                    echo 6379
                    ;;
            esac
        else
            echo $port
        fi
    }

    get_full_hostname() {
        hostname="$1"
        full_hostname="${hostname}.${HEADLESS_SERVICE}"
        echo "${full_hostname}"
    }

    REDISPORT=$(get_port "$HOSTNAME" "REDIS")
    HEADLESS_SERVICE="redis-headless.redis.svc.cluster.local"

    [[ -f $REDIS_PASSWORD_FILE ]] && export REDIS_PASSWORD="$(< "${REDIS_PASSWORD_FILE}")"
    [[ -f $REDIS_MASTER_PASSWORD_FILE ]] && export REDIS_MASTER_PASSWORD="$(< "${REDIS_MASTER_PASSWORD_FILE}")"
    if [[ -f /opt/bitnami/redis/mounted-etc/replica.conf ]];then
        cp /opt/bitnami/redis/mounted-etc/replica.conf /opt/bitnami/redis/etc/replica.conf
    fi
    if [[ -f /opt/bitnami/redis/mounted-etc/redis.conf ]];then
        cp /opt/bitnami/redis/mounted-etc/redis.conf /opt/bitnami/redis/etc/redis.conf
    fi

    echo "" >> /opt/bitnami/redis/etc/replica.conf
    echo "replica-announce-port $REDISPORT" >> /opt/bitnami/redis/etc/replica.conf
    echo "replica-announce-ip $(get_full_hostname "$HOSTNAME")" >> /opt/bitnami/redis/etc/replica.conf
    ARGS=("--port" "${REDIS_PORT}")
    ARGS+=("--replicaof" "${REDIS_MASTER_HOST}" "${REDIS_MASTER_PORT_NUMBER}")
    ARGS+=("--requirepass" "${REDIS_PASSWORD}")
    ARGS+=("--masterauth" "${REDIS_MASTER_PASSWORD}")
    ARGS+=("--include" "/opt/bitnami/redis/etc/redis.conf")
    ARGS+=("--include" "/opt/bitnami/redis/etc/replica.conf")
    exec redis-server "${ARGS[@]}"
---
# Source: redis/templates/headless-svc.yaml
apiVersion: v1
kind: Service
metadata:
  name: redis-headless
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
spec:
  type: ClusterIP
  clusterIP: None
  ports:
    - name: tcp-redis
      port: 6379
      targetPort: redis
  selector:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/name: redis
---
# Source: redis/templates/master/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: redis-master
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
    app.kubernetes.io/component: master
spec:
  type: ClusterIP
  internalTrafficPolicy: Cluster
  sessionAffinity: None
  ports:
    - name: tcp-redis
      port: 6379
      targetPort: redis
      nodePort: null
  selector:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/name: redis
    app.kubernetes.io/component: master
---
# Source: redis/templates/replicas/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: redis-replicas
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
    app.kubernetes.io/component: replica
spec:
  type: ClusterIP
  internalTrafficPolicy: Cluster
  sessionAffinity: None
  ports:
    - name: tcp-redis
      port: 6379
      targetPort: redis
      nodePort: null
  selector:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/name: redis
    app.kubernetes.io/component: replica
---
# Source: redis/templates/master/application.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis-master
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
    app.kubernetes.io/component: master
spec:
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app.kubernetes.io/instance: redis
      app.kubernetes.io/name: redis
      app.kubernetes.io/component: master
  serviceName: redis-headless
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app.kubernetes.io/instance: redis
        app.kubernetes.io/managed-by: Helm
        app.kubernetes.io/name: redis
        app.kubernetes.io/version: 7.2.5
        helm.sh/chart: redis-19.6.0
        app.kubernetes.io/component: master
      annotations:
        checksum/configmap: 86bcc953bb473748a3d3dc60b7c11f34e60c93519234d4c37f42e22ada559d47
        checksum/health: aff24913d801436ea469d8d374b2ddb3ec4c43ee7ab24663d5f8ff1a1b6991a9
        checksum/scripts: b032d0a9786b34ea89cf23766468aa85a6963199094c6da9b17a186cb2e72c33
        checksum/secret: 9a0e0ba16140f6403a7f7d3e12489c6ee668f22d156831fcc36f6899478666da
    spec:
      
      securityContext:
        fsGroup: 1001
        fsGroupChangePolicy: Always
        supplementalGroups: []
        sysctls: []
      serviceAccountName: redis-master
      automountServiceAccountToken: false
      affinity:
        podAffinity:
          
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - podAffinityTerm:
                labelSelector:
                  matchLabels:
                    app.kubernetes.io/instance: redis
                    app.kubernetes.io/name: redis
                    app.kubernetes.io/component: master
                topologyKey: kubernetes.io/hostname
              weight: 1
        nodeAffinity:
          
      enableServiceLinks: true
      terminationGracePeriodSeconds: 30
      containers:
        - name: redis
          image: docker.io/bitnami/redis:7.2.5-debian-12-r0
          imagePullPolicy: "IfNotPresent"
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop:
              - ALL
            readOnlyRootFilesystem: true
            runAsGroup: 1001
            runAsNonRoot: true
            runAsUser: 1001
            seLinuxOptions: {}
            seccompProfile:
              type: RuntimeDefault
          command:
            - /bin/bash
          args:
            - -c
            - /opt/bitnami/scripts/start-scripts/start-master.sh
          env:
            - name: BITNAMI_DEBUG
              value: "false"
            - name: REDIS_REPLICATION_MODE
              value: master
            - name: ALLOW_EMPTY_PASSWORD
              value: "no"
            - name: REDIS_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: redis
                  key: redis-password
            - name: REDIS_TLS_ENABLED
              value: "no"
            - name: REDIS_PORT
              value: "6379"
          ports:
            - name: redis
              containerPort: 6379
          livenessProbe:
            initialDelaySeconds: 20
            periodSeconds: 5
            # One second longer than command timeout should prevent generation of zombie processes.
            timeoutSeconds: 6
            successThreshold: 1
            failureThreshold: 5
            exec:
              command:
                - sh
                - -c
                - /health/ping_liveness_local.sh 5
          readinessProbe:
            initialDelaySeconds: 20
            periodSeconds: 5
            timeoutSeconds: 2
            successThreshold: 1
            failureThreshold: 5
            exec:
              command:
                - sh
                - -c
                - /health/ping_readiness_local.sh 1
          resources:
            limits:
              cpu: 150m
              ephemeral-storage: 1024Mi
              memory: 192Mi
            requests:
              cpu: 100m
              ephemeral-storage: 50Mi
              memory: 128Mi
          volumeMounts:
            - name: start-scripts
              mountPath: /opt/bitnami/scripts/start-scripts
            - name: health
              mountPath: /health
            - name: redis-data
              mountPath: /data
            - name: config
              mountPath: /opt/bitnami/redis/mounted-etc
            - name: empty-dir
              mountPath: /opt/bitnami/redis/etc/
              subPath: app-conf-dir
            - name: empty-dir
              mountPath: /tmp
              subPath: tmp-dir
      volumes:
        - name: start-scripts
          configMap:
            name: redis-scripts
            defaultMode: 0755
        - name: health
          configMap:
            name: redis-health
            defaultMode: 0755
        - name: config
          configMap:
            name: redis-configuration
        - name: empty-dir
          emptyDir: {}
  volumeClaimTemplates:
    - apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
        name: redis-data
        labels:
          app.kubernetes.io/instance: redis
          app.kubernetes.io/name: redis
          app.kubernetes.io/component: master
      spec:
        accessModes:
          - "ReadWriteOnce"
        resources:
          requests:
            storage: "8Gi"
---
# Source: redis/templates/replicas/application.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: redis-replicas
  namespace: "redis"
  labels:
    app.kubernetes.io/instance: redis
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: redis
    app.kubernetes.io/version: 7.2.5
    helm.sh/chart: redis-19.6.0
    app.kubernetes.io/component: replica
spec:
  replicas: 1
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app.kubernetes.io/instance: redis
      app.kubernetes.io/name: redis
      app.kubernetes.io/component: replica
  serviceName: redis-headless
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app.kubernetes.io/instance: redis
        app.kubernetes.io/managed-by: Helm
        app.kubernetes.io/name: redis
        app.kubernetes.io/version: 7.2.5
        helm.sh/chart: redis-19.6.0
        app.kubernetes.io/component: replica
      annotations:
        checksum/configmap: 86bcc953bb473748a3d3dc60b7c11f34e60c93519234d4c37f42e22ada559d47
        checksum/health: aff24913d801436ea469d8d374b2ddb3ec4c43ee7ab24663d5f8ff1a1b6991a9
        checksum/scripts: b032d0a9786b34ea89cf23766468aa85a6963199094c6da9b17a186cb2e72c33
        checksum/secret: 9a0e0ba16140f6403a7f7d3e12489c6ee668f22d156831fcc36f6899478666da
    spec:
      
      securityContext:
        fsGroup: 1001
        fsGroupChangePolicy: Always
        supplementalGroups: []
        sysctls: []
      serviceAccountName: redis-replica
      automountServiceAccountToken: false
      affinity:
        podAffinity:
          
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - podAffinityTerm:
                labelSelector:
                  matchLabels:
                    app.kubernetes.io/instance: redis
                    app.kubernetes.io/name: redis
                    app.kubernetes.io/component: replica
                topologyKey: kubernetes.io/hostname
              weight: 1
        nodeAffinity:
          
      enableServiceLinks: true
      terminationGracePeriodSeconds: 30
      containers:
        - name: redis
          image: docker.io/bitnami/redis:7.2.5-debian-12-r0
          imagePullPolicy: "IfNotPresent"
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop:
              - ALL
            readOnlyRootFilesystem: true
            runAsGroup: 1001
            runAsNonRoot: true
            runAsUser: 1001
            seLinuxOptions: {}
            seccompProfile:
              type: RuntimeDefault
          command:
            - /bin/bash
          args:
            - -c
            - /opt/bitnami/scripts/start-scripts/start-replica.sh
          env:
            - name: BITNAMI_DEBUG
              value: "false"
            - name: REDIS_REPLICATION_MODE
              value: replica
            - name: REDIS_MASTER_HOST
              value: redis-master-0.redis-headless.redis.svc.cluster.local
            - name: REDIS_MASTER_PORT_NUMBER
              value: "6379"
            - name: ALLOW_EMPTY_PASSWORD
              value: "no"
            - name: REDIS_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: redis
                  key: redis-password
            - name: REDIS_MASTER_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: redis
                  key: redis-password
            - name: REDIS_TLS_ENABLED
              value: "no"
            - name: REDIS_PORT
              value: "6379"
          ports:
            - name: redis
              containerPort: 6379
          startupProbe:
            failureThreshold: 22
            initialDelaySeconds: 10
            periodSeconds: 10
            successThreshold: 1
            timeoutSeconds: 5
            tcpSocket:
              port: redis
          livenessProbe:
            initialDelaySeconds: 20
            periodSeconds: 5
            timeoutSeconds: 6
            successThreshold: 1
            failureThreshold: 5
            exec:
              command:
                - sh
                - -c
                - /health/ping_liveness_local_and_master.sh 5
          readinessProbe:
            initialDelaySeconds: 20
            periodSeconds: 5
            timeoutSeconds: 2
            successThreshold: 1
            failureThreshold: 5
            exec:
              command:
                - sh
                - -c
                - /health/ping_readiness_local_and_master.sh 1
          resources:
            limits:
              cpu: 150m
              ephemeral-storage: 1024Mi
              memory: 192Mi
            requests:
              cpu: 100m
              ephemeral-storage: 50Mi
              memory: 128Mi
          volumeMounts:
            - name: start-scripts
              mountPath: /opt/bitnami/scripts/start-scripts
            - name: health
              mountPath: /health
            - name: redis-data
              mountPath: /data
            - name: config
              mountPath: /opt/bitnami/redis/mounted-etc
            - name: empty-dir
              mountPath: /opt/bitnami/redis/etc
              subPath: app-conf-dir
            - name: empty-dir
              mountPath: /tmp
              subPath: tmp-dir
      volumes:
        - name: start-scripts
          configMap:
            name: redis-scripts
            defaultMode: 0755
        - name: health
          configMap:
            name: redis-health
            defaultMode: 0755
        - name: config
          configMap:
            name: redis-configuration
        - name: empty-dir
          emptyDir: {}
  volumeClaimTemplates:
    - apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
        name: redis-data
        labels:
          app.kubernetes.io/instance: redis
          app.kubernetes.io/name: redis
          app.kubernetes.io/component: replica
      spec:
        accessModes:
          - "ReadWriteOnce"
        resources:
          requests:
            storage: "8Gi"

NOTES:
CHART NAME: redis
CHART VERSION: 19.6.0
APP VERSION: 7.2.5

** Please be patient while the chart is being deployed **

Redis&reg; can be accessed on the following DNS names from within your cluster:

    redis-master.redis.svc.cluster.local for read/write operations (port 6379)
    redis-replicas.redis.svc.cluster.local for read-only operations (port 6379)



To get your password run:

    export REDIS_PASSWORD=$(kubectl get secret --namespace redis redis -o jsonpath="{.data.redis-password}" | base64 -d)

To connect to your Redis&reg; server:

1. Run a Redis&reg; pod that you can use as a client:

   kubectl run --namespace redis redis-client --restart='Never'  --env REDIS_PASSWORD=$REDIS_PASSWORD  --image docker.io/bitnami/redis:7.2.5-debian-12-r0 --command -- sleep infinity

   Use the following command to attach to the pod:

   kubectl exec --tty -i redis-client \
   --namespace redis -- bash

2. Connect using the Redis&reg; CLI:
   REDISCLI_AUTH="$REDIS_PASSWORD" redis-cli -h redis-master
   REDISCLI_AUTH="$REDIS_PASSWORD" redis-cli -h redis-replicas

To connect to your database from outside the cluster execute the following commands:

    kubectl port-forward --namespace redis svc/redis-master 6379:6379 &
    REDISCLI_AUTH="$REDIS_PASSWORD" redis-cli -h 127.0.0.1 -p 6379

WARNING: There are "resources" sections in the chart not set. Using "resourcesPreset" is not recommended for production. For production installations, please set the following values according to your workload needs:
  - replica.resources
  - master.resources
+info https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/

@carrodher carrodher added the redis label Jul 1, 2024
@carrodher
Copy link
Member

Could you deploy it setting to true the image.debug parameter? In that way, you can see more information during the initialization process, just in case you get a hint about what's happening.

@tk2023
Copy link
Author

tk2023 commented Jul 1, 2024 •
edited by carrodher
Loading 

$ k logs -f redis-master-0  -n redis
1:C 01 Jul 2024 21:35:03.414 * oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
1:C 01 Jul 2024 21:35:03.414 * Redis version=7.2.5, bits=64, commit=00000000, modified=0, pid=1, just started
1:C 01 Jul 2024 21:35:03.414 * Configuration loaded
1:M 01 Jul 2024 21:35:03.414 * monotonic clock: POSIX clock_gettime
1:M 01 Jul 2024 21:35:03.415 * Running mode=standalone, port=6379.
1:M 01 Jul 2024 21:35:03.415 * Server initialized
1:M 01 Jul 2024 21:35:03.418 * Reading RDB base file on AOF loading...
1:M 01 Jul 2024 21:35:03.418 * Loading RDB produced by version 7.2.5
1:M 01 Jul 2024 21:35:03.418 * RDB age 666439 seconds
1:M 01 Jul 2024 21:35:03.418 * RDB memory usage when created 634.14 Mb
1:M 01 Jul 2024 21:35:03.418 * RDB is base AOF
1:M 01 Jul 2024 21:35:06.579 * Done loading RDB, keys loaded: 147435, keys expired: 0.
1:M 01 Jul 2024 21:35:06.579 * DB loaded from base file appendonly.aof.147.base.rdb: 3.163 seconds
1:M 01 Jul 2024 21:35:08.078 * DB loaded from incr file appendonly.aof.147.incr.aof: 1.499 seconds
1:M 01 Jul 2024 21:35:08.080 * DB loaded from incr file appendonly.aof.148.incr.aof: 0.002 seconds
1:M 01 Jul 2024 21:35:08.080 * DB loaded from incr file appendonly.aof.149.incr.aof: 0.001 seconds
1:M 01 Jul 2024 21:35:08.110 * DB loaded from incr file appendonly.aof.150.incr.aof: 0.030 seconds
1:M 01 Jul 2024 21:35:08.156 * DB loaded from incr file appendonly.aof.151.incr.aof: 0.046 seconds
1:M 01 Jul 2024 21:35:08.208 * DB loaded from incr file appendonly.aof.152.incr.aof: 0.051 seconds
1:M 01 Jul 2024 21:35:08.310 * DB loaded from incr file appendonly.aof.153.incr.aof: 0.102 seconds
1:M 01 Jul 2024 21:35:08.599 * DB loaded from incr file appendonly.aof.154.incr.aof: 0.289 seconds
1:M 01 Jul 2024 21:35:08.830 * DB loaded from incr file appendonly.aof.155.incr.aof: 0.231 seconds
1:M 01 Jul 2024 21:35:09.455 * DB loaded from incr file appendonly.aof.156.incr.aof: 0.625 seconds
1:M 01 Jul 2024 21:35:09.803 * DB loaded from incr file appendonly.aof.157.incr.aof: 0.348 seconds
1:M 01 Jul 2024 21:35:09.804 * DB loaded from incr file appendonly.aof.184.incr.aof: 0.001 seconds
1:M 01 Jul 2024 21:35:09.805 * DB loaded from incr file appendonly.aof.189.incr.aof: 0.001 seconds
1:M 01 Jul 2024 21:35:09.805 * DB loaded from append only file: 6.389 seconds
1:M 01 Jul 2024 21:35:09.805 * Opening AOF incr file appendonly.aof.189.incr.aof on server start
1:M 01 Jul 2024 21:35:09.805 * Ready to accept connections tcp
1:M 01 Jul 2024 21:35:09.805 * Starting automatic rewriting of AOF on 200% growth
1:M 01 Jul 2024 21:35:09.805 # Short write while writing to the AOF file: (nwritten=207, expected=621)
1:M 01 Jul 2024 21:35:09.806 # Error trying to write the temporary AOF manifest file temp-appendonly.aof.manifest: No space left on device
1:M 01 Jul 2024 21:35:09.906 * Starting automatic rewriting of AOF on 200% growth
1:M 01 Jul 2024 21:35:09.906 # Error trying to write the temporary AOF manifest file temp-appendonly.aof.manifest: No space left on device
1:M 01 Jul 2024 21:35:10.007 * Starting automatic rewriting of AOF on 200% growth
1:M 01 Jul 2024 21:35:10.007 # Error trying to write the temporary AOF manifest file temp-appendonly.aof.manifest: No space left on device
1:M 01 Jul 2024 21:35:10.108 * Starting automatic rewriting of AOF on 200% growth

it keeps repeating the No space left on device.

@tk2023
Copy link
Author

tk2023 commented Jul 1, 2024 •
edited by carrodher
Loading

okay. I solved it. The problem is that the PVC sizes (master vs replicate) are different. After I deleted the PVC, it is working now.

Thanks

NAME                          STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS       VOLUMEATTRIBUTESCLASS   AGE
redis-data-redis-master-0     Bound    pvc-fe96e623-8849-4e3a-a499-2b2e5ceb4923   1Gi        RWO            do-block-storage   <unset>                 235d
redis-data-redis-replicas-0   Bound    pvc-b41753db-d0b3-4cb2-ac4e-0376026fad49   8Gi        RWO            do-block-storage   <unset>                 2d7h

@carrodher
Copy link
Member

Glad to see you solved the issue.

@github-actions github-actions bot added the solved label Jul 2, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees

@carrodher carrodher

Labels
redis solved tech-issues The user has a technical issue about an application triage Triage is needed
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
2 participants
@carrodher @tk2023