Introduction to Redis
Learn about the Redis open source project
Redis is an open source (BSD licensed), in-memory data structure store used as a database, cache, and message broker. Redis provides data structures such as
strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams. Redis has built-in replication, Lua scripting, LRU eviction, transactions, and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis Cluster.
You can run atomic operations
on these types, like appending to a string;
incrementing the value in a hash; pushing an element to a
list; computing set intersection,
union and difference;
or getting the member with highest ranking in a sorted set.
To achieve top performance, Redis works with an
in-memory dataset. Depending on your use case, Redis can persist your data either
by periodically dumping the dataset to disk
or by appending each command to a disk-based log. You can also disable persistence if you just need a feature-rich, networked, in-memory cache.
Redis supports asynchronous replication, with fast non-blocking synchronization and auto-reconnection with partial resynchronization on net split.
Redis also includes:
You can use Redis from most programming languages.
Redis is written in ANSI C and works on most POSIX systems like Linux,
*BSD, and Mac OS X, without external dependencies. Linux and OS X are the two operating systems where Redis is developed and tested the most, and we recommend using Linux for deployment. Redis may work in Solaris-derived systems like SmartOS, but support is best effort.
There is no official support for Windows builds.
2 - Redis open source governance
Governance model for the Redis open source project
From 2009-2020, Salvatore Sanfilippo built, led, and maintained the Redis open source project. During this time, Redis had no formal governance structure, operating primarily as a BDFL-style project.
As Redis grew, matured, and expanded its user base, it became increasingly important to form a sustainable structure for its ongoing development and maintenance. Salvatore and the core Redis contributors wanted to ensure the project’s continuity and reflect its larger community. With this in mind, a new governance structure was adopted.
Current governance structure
Starting on June 30, 2020, Redis adopted a light governance model that matches the current size of the project and minimizes the changes from its earlier model. The governance model is intended to be a meritocracy, aiming to empower individuals who demonstrate a long-term commitment and make significant contributions.
The Redis core team
Salvatore Sanfilippo named two successors to take over and lead the Redis project: Yossi Gottlieb (yossigo) and Oran Agra (oranagra)
With the backing and blessing of Redis Ltd., we took this opportunity to create a more open, scalable, and community-driven “core team” structure to run the project. The core team consists of members selected based on demonstrated, long-term personal involvement and contributions.
The current core team members are:
- Project Lead: Yossi Gottlieb (yossigo) from Redis Ltd.
- Project Lead: Oran Agra (oranagra) from Redis Ltd.
- Community Lead: Itamar Haber (itamarhaber) from Redis Ltd.
- Member: Zhao Zhao (soloestoy) from Alibaba
- Member: Madelyn Olson (madolson) from Amazon Web Services
The Redis core team members serve the Redis open source project and community. They are expected to set a good example of behavior, culture, and tone in accordance with the adopted Code of Conduct. They should also consider and act upon the best interests of the project and the community in a way that is free from foreign or conflicting interests.
The core team will be responsible for the Redis core project, which is the part of Redis that is hosted in the main Redis repository and is BSD licensed. It will also aim to maintain coordination and collaboration with other projects that make up the Redis ecosystem, including Redis clients, satellite projects, major middleware that relies on Redis, etc.
Roles and responsibilities
The core team has the following remit:
- Managing the core Redis code and documentation
- Managing new Redis releases
- Maintaining a high-level technical direction/roadmap
- Providing a fast response, including fixes/patches, to address security vulnerabilities and other major issues
- Project governance decisions and changes
- Coordination of Redis core with the rest of the Redis ecosystem
- Managing the membership of the core team
The core team aims to form and empower a community of contributors by further delegating tasks to individuals who demonstrate commitment, know-how, and skills. In particular, we hope to see greater community involvement in the following areas:
- Support, troubleshooting, and bug fixes of reported issues
- Triage of contributions/pull requests
Decision making
- Normal decisions will be made by core team members based on a lazy consensus approach: each member may vote +1 (positive) or -1 (negative). A negative vote must include thorough reasoning and better yet, an alternative proposal. The core team will always attempt to reach a full consensus rather than a majority. Examples of normal decisions:
- Day-to-day approval of pull requests and closing issues
- Opening new issues for discussion
- Major decisions that have a significant impact on the Redis architecture, design, or philosophy as well as core-team structure or membership changes should preferably be determined by full consensus. If the team is not able to achieve a full consensus, a majority vote is required. Examples of major decisions:
- Fundamental changes to the Redis core
- Adding a new data structure
- Creating a new version of RESP (Redis Serialization Protocol)
- Changes that affect backward compatibility
- Adding or changing core team members
- Project leads have a right to veto major decisions
Core team membership
- The core team is not expected to serve for life, however, long-term participation is desired to provide stability and consistency in the Redis programming style and the community.
- If a core-team member whose work is funded by Redis Ltd. must be replaced, the replacement will be designated by Redis Ltd. after consultation with the remaining core-team members.
- If a core-team member not funded by Redis Ltd. will no longer participate, for whatever reason, the other team members will select a replacement.
Community forums and communications
We want the Redis community to be as welcoming and inclusive as possible. To that end, we have adopted a Code of Conduct that we ask all community members to read and observe.
We encourage that all significant communications will be public, asynchronous, archived, and open for the community to actively participate in using the channels described here. The exception to that is sensitive security issues that require resolution prior to public disclosure.
To contact the core team about sensitive matters, such as misconduct or security issues, please email redis@redis.io.
New Redis repository and commits approval process
The Redis core source repository is hosted under https://github.com/redis/redis. Our target is to eventually host everything (the Redis core source and other ecosystem projects) under the Redis GitHub organization (https://github.com/redis). Commits to the Redis source repository will require code review, approval of at least one core-team member who is not the author of the commit, and no objections.
Project and development updates
Stay connected to the project and the community! For project and community updates, follow the project channels. Development announcements will be made via the Redis mailing list.
Updates to these governance rules
Any substantial changes to these rules will be treated as a major decision. Minor changes or ministerial corrections will be treated as normal decisions.
3 - Redis release cycle
How are new versions of Redis released?
Redis is system software and a type of system software that holds user data, so
it is among the most critical pieces of a software stack.
For this reason, Redis' release cycle is such that it ensures highly-stable
releases, even at the cost of slower cycles.
New releases are published in the Redis GitHub repository
and are also available for download. Announcements are sent to the
Redis mailing list and by
@redisfeed on Twitter.
Release cycle
A given version of Redis can be at three different levels of stability:
- Unstable
- Release Candidate
- Stable
Unstable tree
The unstable version of Redis is located in the unstable
branch in the
Redis GitHub repository.
This branch is the source tree where most of the new features are under
development. unstable
is not considered production-ready: it may contain
critical bugs, incomplete features, and is potentially unstable.
However, we try hard to make sure that even the unstable branch is usable most
of the time in a development environment without significant issues.
Release candidate
New minor and major versions of Redis begin as forks of the unstable
branch.
The forked branch’s name is the target release
For example, when Redis 6.0 was released as a release candidate, the unstable
branch was forked into the 6.0
branch. The new branch is the release
candidate (RC) for that version.
Bug fixes and new features that can be stabilized during the release’s time
frame are committed to the unstable branch and backported to the release
candidate branch. The unstable
branch may include additional work that is not
a part of the release candidate and scheduled for future releases.
The first release candidate, or RC1, is released once it can be used for
development purposes and for testing the new version. At this stage, most of
the new features and changes the new version brings are ready for review, and
the release’s purpose is collecting the public’s feedback.
Subsequent release candidates are released every three weeks or so, primarily
for fixing bugs. These may also add new features and introduce changes, but at
a decreasing rate and decreasing potential risk towards the final release
candidate.
Stable tree
Once development has ended and the frequency of critical bug reports for the
release candidate wanes, it is ready for the final release. At this point, the
release is marked as stable and is released with “0” as its patch-level
version.
Versioning
Stable releases liberally follow the usual major.minor.patch
semantic
versioning schema. The primary goal is to provide explicit guarantees regarding
backward compatibility.
Patch-Level versions
Patches primarily consist of bug fixes and very rarely introduce any
compatibility issues.
Upgrading from a previous patch-level version is almost always safe and
seamless.
New features and configuration directives may be added, or default values
changed, as long as these don’t carry significant impacts or introduce
operations-related issues.
Minor versions
Minor versions usually deliver maturity and extended functionality.
Upgrading between minor versions does not introduce any application-level
compatibility issues.
Minor releases may include new commands and data types that introduce
operations-related incompatibilities, including changes in data persistence
format and replication protocol.
Major versions
Major versions introduce new capabilities and significant changes.
Ideally, these don’t introduce application-level compatibility issues.
Release schedule
A new major version is planned for release once a year.
Generally, every major release is followed by a minor version after six months.
Patches are released as needed to fix high-urgency issues, or once a stable
version accumulates enough fixes to justify it.
For contacting the core team on sensitive matters and security issues, please
email redis@redis.io.
Support
As a rule, older versions are not supported as we try very hard to make the
Redis API mostly backward compatible.
Upgrading to newer versions is the recommended approach and is usually trivial.
The latest stable release is always fully supported and maintained.
Two additional versions receive maintenance only, meaning that only fixes for
critical bugs and major security issues are committed and released as patches:
- The previous minor version of the latest stable release.
- The previous stable major release.
For example, consider the following hypothetical versions: 1.2, 2.0, 2.2, 3.0,
3.2.
When version 2.2 is the latest stable release, both 2.0 and 1.2 are maintained.
Once version 3.0.0 replaces 2.2 as the latest stable, versions 2.0 and 2.2 are
maintained, whereas version 1.x reaches its end of life.
This process repeats with version 3.2.0, after which only versions 2.2 and 3.0
are maintained.
The above are guidelines rather than rules set in stone and will not replace
common sense.
4 - Redis sponsors
Current and former Redis sponsors
Between 2015 to June 2020, the work Salvatore Sanfilippo was doing to develop Redis was sponsored by Redis Ltd. Since June 2020, Redis Ltd. has sponsored the Redis project governance.
Past sponsorships:
- The Shuttleworth Foundation has donated 5000 USD to the Redis project in form of a flash grant.
- From May 2013 to June 2015, the work Salvatore Sanfilippo did to develop Redis was sponsored by Pivotal.
- Before May 2013, the project was sponsored by VMware with the work of Salvatore Sanfilippo and Pieter Noordhuis.
- VMware and later Pivotal provided a 24 GB RAM workstation for Salvatore to run the Redis CI test and other long running tests. Later, Salvatore equipped the server with an SSD drive in order to test in the same hardware with rotating and flash drives.
- Linode, in January 2010, provided virtual machines for Redis testing in a virtualized environment.
- Slicehost, January 2010, provided Virtual Machines for Redis testing in a virtualized environment.
- Citrusbyte, in December 2009, contributed part of Virtual Memory implementation.
- Hitmeister, in December 2009, contributed part of Redis Cluster.
- Engine Yard, in December 2009, contributed blocking POP (BLPOP) and part of the Virtual Memory implementation.
Also thanks to the following people or organizations that donated to the Project:
The Redis community is grateful to Redis Ltd., Pivotal, VMware and to the other companies and people who have donated to the Redis project. Thank you.
redis.io
Citrusbyte sponsored the creation of the official
Redis logo (designed by Carlos Prioglio) and
transferred its copyright to Salvatore Sanfilippo.
They also sponsored the initial implementation of this site by
Damian Janowski and Michel
Martens.
The redis.io
domain was donated for a few years to the project by I Want My
Name.
5 - Redis license
Redis license and trademark information
Redis is open source software released under the terms of the three clause BSD license. Most of the Redis source code was written and is copyrighted by Salvatore Sanfilippo and Pieter Noordhuis. A list of other contributors can be found in the git history.
The Redis trademark and logo are owned by Redis Ltd. and can be
used in accordance with the Redis Trademark Guidelines.
Three clause BSD license
Every file in the Redis distribution, with the exceptions of third party files specified in the list below, contain the following license:
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
-
Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
-
Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
-
Neither the name of Redis nor the names of its contributors may be used
to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS”
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Third-party files and licenses
Redis uses source code from third parties. All this code contains a BSD or BSD-compatible license. The following is a list of third-party files and information about their copyright.
-
Redis uses the LHF compression library. LibLZF is copyright Marc Alexander Lehmann and is released under the terms of the two-clause BSD license.
-
Redis uses the sha1.c
file that is copyright by Steve Reid and released under the public domain. This file is extremely popular and used among open source and proprietary code.
-
When compiled on Linux Redis uses the Jemalloc allocator, that is copyright by Jason Evans, Mozilla Foundation and Facebook, Inc and is released under the two-clause BSD license.
-
Inside Jemalloc the file pprof
is copyright Google Inc and released under the three-clause BSD license.
-
Inside Jemalloc the files inttypes.h
, stdbool.h
, stdint.h
, strings.h
under the msvc_compat
directory are copyright Alexander Chemeris and released under the three-clause BSD license.
-
The libraries hiredis and linenoise also included inside the Redis distribution are copyright Salvatore Sanfilippo and Pieter Noordhuis and released under the terms respectively of the three-clause BSD license and two-clause BSD license.