[Sandbox] Redis Operator

[iamabhishek-dubey]

Application contact emails

abhishek.dubey@opstree.com,sandeep@opstree.com

Project summary

A Golang based redis operator that will make/oversee Redis standalone and cluster mode setup on top of the Kubernetes.

Project description

A Golang-based redis operator that will make/oversee Redis standalone/cluster/replication/sentinel mode setup on top of the Kubernetes. It can create a redis cluster setup with best practices on the Cloud and the Bare-metal environment. Also, it provides an in-built monitoring capability using redis-exporter.

The type of Redis setup which is currently supported:-

• Redis Cluster
• Redis Standalone
• Redis Replication
• Redis Sentinel

Purpose

People face multiple problems while setting up redis setup on Kubernetes, especially cluster type setup. The purpose of creating this operator is to provide an easy and production-ready interface for redis setup that includes best practices, security controls, monitoring, and management.

Org repo URL (provide if all repos under the org are in scope of the application)

N/A

Project repo URL in scope of application

https://github.com/OT-CONTAINER-KIT/redis-operator

Additional repos in scope of the application

No response

Website URL

https://redis-operator.opstree.dev/

Roadmap

https://github.com/OT-CONTAINER-KIT/redis-operator/blob/main/ROADMAP.md

Roadmap context

We initially used issues to manage the roadmap, but now we have started publishing it in a Markdown file, which will be converted to a GitHub project board.

Contributing guide

https://github.com/OT-CONTAINER-KIT/redis-operator/blob/main/CONTRIBUTING.md

Code of Conduct (CoC)

https://github.com/OT-CONTAINER-KIT/redis-operator/blob/main/CODE_OF_CONDUCT.md

Adopters

No response

Contributing or sponsoring org

https://opstree.com/

Maintainers file

https://github.com/OT-CONTAINER-KIT/redis-operator/blob/main/CODEOWNERS

IP policy

• If the project is accepted, I agree the project will follow the CNCF IP Policy

Will the project require a license exception?

N/A

Trademark and accounts

• If the project is accepted, I agree to donate all project trademarks and accounts to the CNCF

Standard or specification?

N/A

Why CNCF?

The CNCF is a key player in the cloud-native ecosystem, supporting projects that advance containerization, microservices, and platform engineering. Integrating the Redis Operator under the CNCF umbrella can provide several benefits and align the Redis Operator with the broader cloud-native landscape. Here's why the CNCF would be an ideal home for a Redis Operator:

• Alignment with Cloud-Native Principles
• Interoperability and Ecosystem Synergy
• Reliability, Stability, and Governance
• Enterprise Adoption and Support
• Scalability and Innovation

Benefit to the landscape

Adding the Redis Operator to the Cloud Native Computing Foundation (CNCF) landscape offers several unique benefits and addresses specific gaps or challenges within the CNCF ecosystem. Redis, as a widely-used in-memory data structure store, plays a critical role in modern cloud-native architectures, especially for caching, real-time data processing, messaging, and session storage. The Redis Operator provides Kubernetes-native management for Redis instances, which adds significant value to CNCF's growing landscape of containerized applications and services.

Key Benefits:

• The Redis Operator fills a critical gap by providing stateful management for Redis in Kubernetes environments. Redis is one of the most commonly used databases for cloud-native apps, and having a Kubernetes-native operator simplifies Redis' operational complexities, such as scaling, failover, backup, and data persistence.
• By integrating the Redis Operator into CNCF, Kubernetes users will have an established, robust mechanism for managing stateful services, thus strengthening the CNCF ecosystem's ability to handle both stateless and stateful workloads seamlessly.
• Kubernetes-native Management for Redis: Redis, while highly scalable and performant, can be complex to operate at scale. The Redis Operator abstracts much of this complexity, making it easier for users to deploy, scale, and maintain Redis clusters using Kubernetes-native tools and best practices.
• The Redis Operator addresses this need by ensuring that Redis can scale and handle failover automatically within Kubernetes, allowing it to act as a robust caching layer in highly dynamic environments. Adding this operator to the CNCF landscape will make distributed caching a first-class citizen in Kubernetes and cloud-native architectures, contributing to the broader vision of managing distributed systems more effectively.
• By incorporating the Redis Operator, CNCF will enhance Kubernetes' capabilities for managing high-availability distributed systems and increase the trust in Kubernetes for handling mission-critical applications in production.

Cloud native 'fit'

The Redis Operator fits into the Cloud Native landscape as a key component of managing stateful applications in a Kubernetes-centric, cloud-native architecture. The project exemplifies many core principles of the cloud-native ecosystem, primarily focused on containerization, orchestration, scalability, automation, and operational efficiency.

Cloud-Native Core Principles the Redis Operator Embodies:-

• Containerization -> Redis as a containerized service: The Redis Operator is designed to manage Redis instances that run inside containers, typically on Kubernetes. Containers are the fundamental unit of application deployment in the cloud-native ecosystem, and the Redis Operator provides the automation needed to deploy and manage Redis instances as part of Kubernetes workloads.
• Orchestration (Kubernetes Native) -> Kubernetes is the cornerstone of cloud-native orchestration. It enables users to define their applications' desired state and automatically ensures that the system converges to that state. The Redis Operator leverages Kubernetes' declarative configuration model, allowing users to specify how Redis instances should be configured (e.g., replicas, clusters, persistence settings), and the operator ensures that these configurations are maintained.
• Scalability -> Kubernetes excels at managing dynamic, scalable applications. The Redis Operator directly supports scaling Redis clusters based on application demand. It automatically adjusts the number of Redis nodes or partitions to accommodate changing loads, thus enabling cloud-native applications to scale easily.
• Declarative Management -> The Redis Operator follows Kubernetes' declarative management model. Users define the desired state of Redis clusters (e.g., number of replicas, persistence mode, etc.), and the operator ensures the system continuously converges to that state. This approach allows for self-healing capabilities, where the operator detects and corrects configuration drift automatically.
• DevOps and Automation -> Kubernetes' declarative API allows Redis instances to be treated as code, with YAML manifests that describe the desired state of Redis clusters. The Redis Operator helps automate the deployment, scaling, and management of Redis instances, further driving automation in cloud-native infrastructures. This fits into the broader DevOps culture of automating infrastructure and operations.

Cloud native 'integration'

The Redis Operator complements and depends on several key CNCF projects fundamental to the cloud-native ecosystem, particularly in orchestration, scalability, observability, and security. Below is an overview of the CNCF projects that the Redis Operator interacts with, how it complements them, and, in some cases, how it may depend on them.

• Kubernetes

  • Dependence: The Redis Operator is designed to run natively on Kubernetes and is built around Kubernetes’ Custom Resource Definitions (CRDs) and Controllers. The operator uses Kubernetes' StatefulSets and Persistent Volumes to manage Redis clusters cloud-natively.
  • How It Complements Kubernetes: The Redis Operator enhances Kubernetes’ capabilities to manage stateful workloads (like Redis clusters), something it traditionally struggled with since it was initially optimized for stateless applications. The Redis Operator provides a declarative management model that allows Redis instances to be scaled, backed up, and healed automatically, aligning perfectly with Kubernetes' principles.

• Helm

  • Complement: The Redis Operator can be packaged and deployed using Helm, a popular Kubernetes package manager. Helm simplifies the deployment of Kubernetes applications and offers templating functionality, making it easier to deploy and configure Redis clusters.
  • How It Complements Helm: Helm enables reproducible and easily configurable Redis Operator deployments across environments. Helm charts can package the Redis Operator along with Kubernetes manifests (like CRDs and StatefulSets), making it simple for users to install and manage the Redis Operator on any Kubernetes cluster.

• Prometheus

  • Complement: Prometheus is a metrics collection and monitoring system that integrates seamlessly with the Redis Operator to collect Redis-specific metrics (such as memory usage, command statistics, and replication status).
  • How It Complements Helm: The Redis Operator provides exporters or integrates with the Prometheus exporter for Redis to expose critical performance metrics. These metrics can then be scraped by Prometheus, enabling operators and developers to monitor Redis performance in real-time. This integration provides crucial observability for Redis instances running in Kubernetes.

Cloud native overlap

This project doesn't overlap with any CNCF projects.

Similar projects

N/A

Landscape

No, we are not currently listed on CNCF Landscape.

Business Product or Service to Project separation

"This project is unrelated to any product or service."

Project "Domain Technical Review"

No response

CNCF contacts

No response

Additional information

No response

[dims]

@iamabhishek-dubey have you see previous discussions like cncf/foundation#750 ? Is there a valkey angle to this operator? What is your view here? Are you sure about your answer to "Will the project require a license exception"?

[iamabhishek-dubey]

Hey @dims, yes I have gone through the discussion but the current redis version that we are supporting is still with the older version of the license. The redis license change is associated with the 7.4 and in the redis operator, we are only supporting the 7.0.X versions.
https://redis.io/blog/redis-adopts-dual-source-available-licensing/

Also, we have a roadmap for integrating Valkey support to this operator. So this operator will gradually start supporting the Valkey versions as well.

On the question "Are you sure about your answer to "Will the project require a license exception"?", yes since we are not going to support the 7.4 version in our operator, we don't think that we require a license exception.

[jeremyrickard]

How far off do you envision valkey support being? Would the name remain the same? Given the stance that you will only support 7.0.x versions of Redis, what changes do you envision coming for Redis support?

[iamabhishek-dubey]

Hey @jeremyrickard https://redis.io/blog/agplv3/ Redis is open source again. This news came yesterday itself. In this particular case, we will move Valkey to a separate project, and this will remain redis-operator

From 8.X versions, Redis will be open-source again under the AGPLv3 license. I would appreciate your thoughts on this as well.

[especially-relative]

Wasn't the operator under a different license from redis itself?

[iamabhishek-dubey]

Yes, @danieljkemp, the Redis operator is under Apache License 2.0, but I guess @jeremyrickard was talking about impact of Redis license on this operator.

[linsun]

Hi @iamabhishek-dubey and team, curious if have you considered submitting the redis operator to the redis project? I asked because we host istio operator in istio and istio-ecosystem organization in github.