Redis 8.2

Summary: What's new in Redis 8.2

Overview

Redis 8.2 builds on the foundation of Redis 8.0 with significant performance and memory optimizations, enhanced streaming capabilities, and improved cluster management tools.

This release delivers major improvements across multiple areas:
- Enhanced Redis Streams with new commands for better consumer group management
- New bitmap operations for advanced bit manipulation
- Advanced cluster monitoring with per-slot usage metrics
- Optimized vector search with new compression algorithms
- Enhanced keyspace notifications with new event types
- More than 15 performance and resource utilization improvements

Below is a detailed breakdown of these updates.

Security improvements

Redis 8.2 includes important security fixes:
- **CVE-2025-27151**: Fixed potential stack overflow and RCE vulnerability in redis-check-aof.
- **CVE-2025-32023**: Fixed out-of-bounds write vulnerability in HyperLogLog commands.
- **CVE-2025-48367**: Improved connection handling to retry accepting connections even when errors occur.

New features

Enhanced Redis Streams

Redis 8.2 introduces powerful new commands that simplify consumer group management and stream lifecycle operations:

- [`XDELEX`](): Delete entries from streams with advanced consumer group handling options.
- [`XACKDEL`](): Acknowledge and delete stream entries in a single atomic operation.

These commands include `KEEPREF`, `DELREF`, and `ACKED` options that give you precise control over how consumer group references are handled during entry deletion. This simplifies common patterns where you need to clean up acknowledged entries while working with multiple consumer groups.

The [`XADD`]() and [`XTRIM`]() commands have also been extended with these same options, providing consistent behavior across all commands that remove stream entries.

Cluster monitoring improvements

The new [`CLUSTER SLOT-STATS`]() command provides detailed per-slot usage metrics including:
- Key count per slot
- CPU time consumption
- Network ingress and egress

This enhanced visibility helps you optimize cluster performance and identify hotspots in your data distribution.

Vector search enhancements

The `VSIM` command now supports the `IN` operator for filtering expressions, giving you more flexibility when performing vector similarity searches with complex filtering criteria.

Enhanced bitmap operations

Redis 8.2 extends the [`BITOP`]() command with new operators that provide more sophisticated bit manipulation capabilities:

- **DIFF**: Perform bitwise difference operations between bitmaps.
- **DIFF1**: Calculate the difference with optimized single-bit operations.
- **ANDOR**: Combine AND and OR operations in a single command.
- **ONE**: Specialized operation for single-bit scenarios.

These new operators enable more complex bitmap workflows and can simplify operations that previously required multiple commands.

Improved keyspace notifications

Redis 8.2 introduces new keyspace notification event types that provide better visibility into data changes:

- **OVERWRITTEN**: Triggered when a key's value is completely overwritten.
- **TYPE_CHANGED**: Fired when a key's data type changes.

These events help you build more responsive applications by providing granular notifications about specific types of data modifications.

Improvements

Redis 8.2 delivers substantial performance improvements across core operations.

Performance optimizations

- **BITCOUNT**: Enhanced with prefetching optimizations for faster bit counting operations.
- **SCAN**: Optimized to perform expiration checks only on databases with volatile keys, reducing unnecessary overhead.
- **List operations**: `LREM`, `LPOS`, and `LINSERT` benefit from cached `string2ll` results in `quicklistCompare`.
- **Sorted set operations**: `ZRANK` and related commands use the same caching optimizations.
- **Key operations**: `COPY`, `RENAME`, and `RESTORE` are optimized when TTL is used.
- **Client management**: Reduced overhead in client cron operations to avoid blocking the main thread.
- **Vector operations**: Improved RDB loading and RESTORE speed for vector sets by storing worst link information.

Memory efficiency improvements

- **JSON data types**: Memory footprint improvements through number inlining.
- **Memory tracking**: Reduced overhead associated with tracking malloc's usable memory.
- **Expiry handling**: Optimized expiry checks in scan callbacks.
- **Vector compression**: Additional compression variants for the SVS-VAMANA vector index reduce memory usage.

Vector search performance

Redis 8.2 introduces the `SHARD_K_RATIO` parameter for KNN vector queries in Redis clusters. This unstable feature allows you to favor network latency over accuracy, providing faster responses when exact precision isn't critical.

Enhanced metrics

Redis 8.2 provides new metrics to help you monitor and troubleshoot your Redis instances.

#### Memory metrics

- `used_memory_peak_time`: Timestamp when `used_memory_peak` was reached

#### Replication metrics

- `master_current_sync_attempts`: Number of sync attempts since last disconnection
- `master_total_sync_attempts`: Total number of sync attempts to master
- `master_link_up_since_seconds`: Duration since the replication link was established
- `total_disconnect_time_sec`: Cumulative time the replica has been disconnected

These metrics provide better visibility into replication health and help you identify patterns in connection stability.

Component versions

Redis 8.2 continues the unified distribution approach introduced in Redis 8.0, delivering all functionality in a single Redis Open Source package without separate modules.


Redis 8.4

Summary: What's new in Redis 8.4

Overview

Redis 8.4 builds on the foundation of Redis 8.2 with significant enhancements to cluster operations, string manipulation, and stream processing capabilities.

This release delivers major improvements across multiple areas:
- Atomic cluster slot migration for zero-downtime operations
- Enhanced string operations with atomic compare-and-set functionality
- Advanced stream processing with idle entry claiming
- Hybrid search capabilities combining multiple ranking algorithms
- High-performance SIMD optimizations for bit operations and vector processing
- Improved JSON handling with better memory efficiency

Below is a detailed breakdown of these updates.

New features

Atomic cluster operations

Redis 8.4 introduces the [`CLUSTER MIGRATION`]() command, which enables atomic slot migration between cluster nodes. This command ensures zero-downtime cluster operations by moving slots and their associated data in a single atomic operation, eliminating the brief unavailability window that previously occurred during slot migrations.

Enhanced string operations

Redis 8.4 extends string manipulation capabilities with powerful new commands that enable atomic compare-and-set operations:

- [`DELEX`](): Delete a key only if its value matches a specified condition.
- [`DIGEST`](): Generate cryptographic digests of key values for integrity verification.

The [`SET`]() command now supports atomic compare-and-set and compare-and-delete operations through new extensions, enabling you to implement lock-free data structures and optimistic concurrency control patterns.

Multi-key expiration management

The new [`MSETEX`]() command allows you to set multiple keys and update their expiration times in a single atomic operation. This simplifies batch operations where you need to maintain consistent TTL values across related keys.

Advanced stream processing

Redis 8.4 enhances stream processing with the `CLAIM min-idle-time` option for [`XREADGROUP`](). This feature enables consumer groups to automatically claim and process both idle pending entries and new incoming entries in a single operation, simplifying consumer group management and improving processing efficiency.

Hybrid search capabilities

The new `FT.HYBRID` command introduces hybrid queries that combine multiple ranking algorithms using Reciprocal Rank Fusion (RRF) and linear combination methods. This enables you to create sophisticated search experiences that leverage both semantic similarity and traditional text matching.

Enhanced AOF reliability

Redis 8.4 introduces auto-repair options for corrupted AOF (Append Only File) tails during startup. The new `aof-load-corrupt-tail-max-size` configuration parameter allows Redis to automatically repair minor AOF corruption, improving system resilience and reducing manual intervention requirements.

Improvements

Redis 8.4 delivers substantial performance improvements through advanced SIMD optimizations and enhanced algorithms.

Performance optimizations

- **BITCOUNT**: Enhanced with AVX2 and AVX512 popcount implementations for x86 architectures, plus Arm Neon SIMD vectorization for ARM processors.
- **HyperLogLog**: Optimized with branchless comparisons and Arm Neon SIMD vectorization for improved cardinality estimation performance.
- **Vector operations**: `VADD` and `VSIM` commands benefit from AVX2 and AVX512 dot product implementations for faster vector processing.
- **Command processing**: New lookahead prefetching parses multiple commands in advance through a lookahead pipeline, reducing processing latency.

Memory efficiency improvements

- **JSON data types**: Improved memory footprint through homogeneous array optimization and short string inlining.
- **Lua integration**: Enhanced JSON array handling with the new `decode_array_with_array_mt` configuration parameter for better memory utilization.

Search and indexing enhancements

Redis 8.4 introduces several improvements to search functionality:

- **Default scoring**: The new `search-default-scorer` parameter sets BM25STD as the default text and tag scorer, providing better relevance ranking out of the box.
- **OOM handling**: The `search-on-oom` parameter controls query behavior during out-of-memory conditions, with options to ignore, fail, or return partial results.
- **Multi-threading**: The `search-io-threads` parameter allows you to configure communication threads for cluster manager coordination, improving search performance in clustered environments.
- **Index updates**: Search indexes now support updates during atomic slot migrations, maintaining search functionality during cluster operations.

Enhanced configuration

Redis 8.4 introduces new configuration parameters that give you greater control over system behavior:

- `lookahead`: Runtime-configurable lookahead depth for command prefetching (default: 16)
- `aof-load-corrupt-tail-max-size`: Maximum corrupted tail size for automatic AOF repair
- `decode_array_with_array_mt`: Controls how Lua handles empty JSON arrays

Component versions

Redis 8.4 continues the unified distribution approach, delivering all functionality in a single Redis Open Source package without separate modules. This includes:

- **RedisTimeSeries**: Enhanced with `HELP` and `COMMAND DOCS` support for time series commands
- **RedisBloom**: Improved with `HELP` and `COMMAND DOCS` support for probabilistic commands
- **RediSearch**: Advanced hybrid search capabilities and improved cluster coordination

Known limitations

When using Redis 8.4, be aware of these current limitations:

- Search commands (`FT.SEARCH`, `FT.AGGREGATE`, `FT.CURSOR`, `FT.HYBRID`) and time series commands (`TS.MGET`, `TS.MRANGE`, `TS.MREVRANGE`, `TS.QUERYINDEX`) may return partial results or duplicates during atomic slot migration.
- `FT.PROFILE`, `FT.EXPLAIN`, and `FT.EXPLAINCLI` don't include `FT.HYBRID` options.
- `FT.HYBRID` metrics aren't displayed in `FT.INFO` and `INFO` commands.
- Several `FT.HYBRID` options (`EXPLAINSCORE`, `SHARD_K_RATIO`, `YIELD_DISTANCE_AS`, `WITHCURSOR`) are not yet available.
- Post-filtering after the `COMBINE` step using `FILTER` is not currently supported.


Redis 8.6

Summary: What's new in Redis 8.6

Overview

Redis 8.6 builds on the foundation of Redis 8.4 with significant enhancements to stream reliability, memory management, and security features.

This release delivers major improvements across multiple areas:
- Stream idempotency with at-most-once delivery guarantees
- New eviction policies for least recently modified data
- Hot key detection and reporting capabilities
- TLS certificate-based automatic client authentication
- Enhanced time series support with NaN values and new aggregators
- Substantial memory reduction for hashes and sorted sets
- Keys memory size histograms for better monitoring
- More than 20 performance and resource utilization improvements

Below is a detailed breakdown of these updates.

Security improvements

Redis 8.6 includes important security and privacy enhancements:
- **Privacy protection**: Personally identifiable information is now hidden from ACL logs and server logs across Redis core and modules.
- **ACL security fix**: Fixed key-pattern bypass vulnerability in `MSETEX` command.
- **Module security**: Addressed out-of-bounds read vulnerability when loading invalid RDB files in RedisBloom.

New features

Stream idempotency

Redis 8.6 introduces powerful idempotency features for [Redis Streams]() that provide at-most-once delivery guarantees:

- **IDMPAUTO argument**: Automatically generates idempotent identifiers for `XADD` operations.
- **IDMP argument**: Allows manual specification of idempotent identifiers.

These features prevent duplicate entries in streams, making Redis Streams more reliable for critical data processing pipelines where duplicate processing could cause issues.

Enhanced memory management

Redis 8.6 introduces new [eviction policies]() that provide more granular control over memory management:

- **volatile-lrm**: Evicts keys with expiration times based on least recently modified criteria.
- **allkeys-lrm**: Evicts any keys based on least recently modified criteria.

These policies complement existing LRU (Least Recently Used) policies by focusing on modification patterns rather than access patterns, providing better control for write-heavy workloads.

Hot key detection

The new [`HOTKEYS`]() commands enable real-time detection and reporting of frequently accessed keys. This feature helps identify performance bottlenecks and optimize data distribution in clustered environments.

TLS certificate-based authentication

Redis 8.6 introduces automatic client authentication using TLS certificates. This feature streamlines secure connections by automatically mapping TLS certificates to Redis users, reducing the need for password-based authentication in certificate-enabled environments.

Enhanced time series capabilities

Redis 8.6 extends [time series]() functionality with:

- **NaN value support**: Time series can now store and process Not-a-Number values for incomplete or invalid data points.
- **New aggregators**: `COUNTNAN` and `COUNTALL` aggregators provide better analytics for datasets containing NaN values.

Memory monitoring and analytics

Redis 8.6 introduces advanced memory monitoring capabilities:

- **Keys memory size histograms**: Collect detailed memory consumption histograms per data type to better understand memory usage patterns.
- **Per-slot statistics**: New cluster slot statistics provide insights into resource consumption across cluster nodes.

Improvements

Redis 8.6 delivers substantial performance improvements across core operations and data structures.

Performance optimizations

- **Reply optimization**: Copy-avoidance path reduces memory copies for bulk string replies and optimized list node allocation.
- **Data structure improvements**: Hash and sorted set operations benefit from unified field/value and score/value structures, delivering substantial memory reduction.
- **Iterator optimization**: Improved listpack iterator performance for hash field operations.
- **Command optimization**: Enhanced `ZRANK`, `XREADGROUP CLAIM` performance and optimized set commands with expiration.
- **Prefetching enhancements**: Improved prefetching logic and sizing algorithms.
- **Hardware utilization**: ARM AArch64 systems now utilize hardware clocks by default for better performance.
- **ACL optimization**: Optimized user ACL permission verification for faster access control.
- **Vector operations**: Enhanced vector set operations with optimized distance calculations for Intel, AMD, and ARM architectures.
- **System efficiency**: Reduced per-command syscalls by reusing cached time when hardware monotonic clock is available.

Replication improvements

- **Diskless replication**: RDB compression is now disabled during diskless replication to improve transfer speeds.
- **Configuration flexibility**: New `flushdb` option for `repl-diskless-load` provides better control over dataset handling during replication.

Configuration enhancements

Redis 8.6 introduces new configuration parameters that provide greater control over system behavior:

- **Stream idempotency**: `stream-idmp-duration` and `stream-idmp-maxsize` control default settings for idempotent stream production.
- **TLS authentication**: `tls-auth-clients-user` enables certificate-based automatic client authentication.
- **Memory policies**: Support for new `volatile-lrm` and `allkeys-lrm` eviction policies.
- **Cluster monitoring**: `cluster-slot-stats-enabled` enables per-slot resource consumption statistics collection.
- **Memory analytics**: `key-memory-histograms` enables collection of memory consumption histograms per data type.

Modules API enhancements

Redis 8.6 extends the modules API with new key metadata capabilities:

- **RM_CreateKeyMetaClass**: Define new key-metadata classes for custom data organization.
- **RM_ReleaseKeyMetaClass**: Release key-metadata classes when no longer needed.
- **RM_SetKeyMeta**: Attach or update metadata values for keys under specific metadata classes.
- **RM_GetKeyMeta**: Retrieve metadata values for keys under specific metadata classes.

These APIs enable module developers to associate custom metadata with Redis keys, opening new possibilities for advanced data management and analytics.

Enhanced monitoring and metrics

Redis 8.6 introduces new metrics that provide deeper insights into system behavior:

- **Memory distribution metrics**: New metrics (`db0_distrib_lists_sizes`, `db0_distrib_sets_sizes`, `db0_distrib_hashes_sizes`, `db0_distrib_zsets_sizes`) provide detailed memory usage distribution across different data types.
- **TLS authentication metrics**: `acl_access_denied_tls_cert` tracks failed TLS certificate-based authentication attempts for security monitoring.

Component versions

Redis 8.6 continues the unified distribution approach, delivering all functionality in a single Redis Open Source package without separate modules. This includes:

- **RedisTimeSeries**: Enhanced with NaN value support and new aggregation functions.
- **RedisBloom**: Improved security with RDB loading fixes and atomic slot migration support.
- **RedisJSON**: Better privacy protection and enhanced atomic slot migration capabilities.

Known limitations

When using Redis 8.6, be aware of these current limitations:

- **Redis Search**: During load rebalancing operations (such as Atomic Slot Migration), cursors may miss some results due to data movement between nodes.
- **Stream idempotency**: Avoid using `XADD` with the new `IDMP` or `IDMPAUTO` options when using `appendonly yes` with `aof-use-rdb-preamble no` (non-default configuration). This limitation will be removed in the next patch release.

- [Redis 8.6]()


What's new?

Summary: High-level description of important updates to the Develop section

Summary: What's new in Redis 8.6

Redis 8.6

Summary: What's new in Redis 8.4

Redis 8.4

Summary: What's new in Redis 8.2

Redis 8.2

Summary: What's new in Redis 8.0

Redis 8.0

Summary: What's new in Redis 7.4

Redis 7.4

Summary: What's new in Redis 7.2

Redis 7.2

Summary: What's new in Redis 6.2

Redis 6.2

Summary: Highlights of what's new for Redis feature sets

Redis feature sets

Q3 2025 (July - September) Updates

Tools

- Added [redis-cli installation instructions]()

---

Redis AI & Vectors

- Updated [vector types documentation]() for INT8 and UINT8
- Added [GEO search precision information]()
- Enhanced [LangCache SDK]() with savings calculator and improved API documentation

---

Data Types

- [Bitmaps]():
  - Added BITOP documentation with Python testable code examples
  - Added bit operation diagrams

---

Client Libraries

#### Java (Jedis)
- Added [vector set embedding examples]()

#### .NET (NRedisStack)
- Added [vector set embedding examples]()
- Enabled C#-Sync and C#-Async client variants with async examples on the landing page

#### Rust (NEW)
- Added initial [Rust client documentation]()
- Enabled Rust-Sync and Rust-Async client variants
- Landing page code examples for Rust

---

Documentation Updates

- Added [close/quit details]() to client landing pages
- Added [redlock-universal]() to Redlock implementations list
- Fixed [keyspace notifications]() typo
- Updated Unicode quotes to ASCII throughout documentation
- Fixed broken links and improved cross-references

Q2 2025 (April - June) Updates

Tools

- Redis Insight [v2.70.1 release notes]()
- Redis Insight [v1.4.0 release notes]()
- Updated [Redis Insight pages]() with consistent image-card layout
- Added Redis Insight SVG icons and download links across [tools documentation]()

---

Redis AI & Vectors

- Reorganized [search and query documentation]() under AI section
- Added [AI video tutorials]() with YouTube content
- Added [AI notebook collection]() with 8 new notebook links
- Expanded vector examples across multiple clients:
  - [Python vector sets]()
  - [Go vector sets]()
  - [JavaScript vector sets]()
  - [Lettuce vector queries]()
  - [Lettuce vector sets]()
- Updated [redisvl documentation]() for versions 0.6.0-0.8.2
- Added [LangCache SDK]() documentation with [API reference]()

---

Redis 8.0 & 8.2 Features

- [Redis Open Source 8.2 documentation]()
- Updated [Redis 8.0 release notes]()
- [Redis Search expiration capabilities]() in Redis 8
- Enhanced [TAG documentation]() per GitHub issues
- [Vector quantization and compression]() moved to dedicated page

---

Data Types

- TimeSeries:
  - [Enhanced time series examples]() with query and aggregation info
  - Added testable code examples (TCE) support
- Probabilistic:
  - Added testable examples for [Python](), [C#](), [Java](), and [Go]()
  - Updated [Cuckoo filter documentation]()

---

Client Libraries

#### Python (redis-py)
- Added [reconnection examples]()
- Enhanced [timeout and retry details]()
- Fixed [pip install command]() for redis-py entraid extension
- Added [Binder environment links]() for Python examples

#### Java (Jedis)
- Updated to [latest Jedis version]()
- Added [reconnection examples]()
- Enhanced [probabilistic data type examples]()

#### Node.js
- Added [command reliability information]()
- Fixed [reconnection details]()

#### .NET (NRedisStack)
- Added [retries and timeouts]() to production usage advice
- Enhanced [dialect 2 notes]()

#### Go (go-redis)
- Added [retries and timeouts]() to production usage
- Enhanced [dialect 2 notes]()
- Added [Connect with AMR]() page.

#### Lettuce
- Updated to [latest Lettuce version]()
- Added [command reliability information]()
- Added [JSON query examples]()

#### PHP (Predis)
- Enhanced [dialect 2 notes]()

---

Documentation Structure & Navigation

- Reorganized [develop section navigation]() with improved sidebar structure
- Moved [programmability section]() into develop area
- Relocated [patterns folder]() to clients section
- Added [Using commands section]() to develop area
- Enhanced [keyspace notifications]() and [pub/sub]() documentation
- Updated [transactions]() and [pipeline]() pages
- Added comprehensive aliases for backward compatibility

---

Protocol & Technical Updates

- Fixed [RESP protocol specification]() attribute byte documentation
- Enhanced [FT.AGGREGATE expression precedence]() documentation
- Updated [distributed locks]() documentation
- Fixed [FP32 vectorsets endianness]() documentation

Q1 2025 (January - March) Updates

Tools

- Redis Insight [v2.66 release notes]()
- Updated CLI output samples for [`bigkeys`, `memkeys`, `keystats`]()

---

Redis AI & Vectors

- Expanded vector examples:
  - [Python]()
  - [Node.js]()
  - [Java (Jedis)]()
  - [Go]()
  - [.NET]()
- Updated AI integrations:
  - [AI overview]()
  - [RAG intro]()
  - [Redis in AI]()

---

Data Types

- TimeSeries:
  - [`COMPACTION_POLICY`]()
  - [Client-side caching update]()
- JSON:
  - [Active memory defragmentation]()
- Probabilistic:
  - [Bloom filter]()
  - [Count-min sketch]()
  - [Top-K]()
  - [Cuckoo filter]()

---

Commands & API Docs

- Pages updated for format and accuracy:
  - [ACL SETUSER]()
  - [JSON.GET]()
  - [TS.ADD]()
  - [SCAN]()
  - [SORT]()
- RESP3 reply types documented in [Hiredis command page]()
- [CSC behavior clarified]()

---

Search & Query

- Best practices:
  - [Dev-to-prod guide]()
  - [Scalable queries]()
  - [Index lifecycle]()
- New/updated topics:
  - [Autocomplete]()
  - [Escaping & tokenization]()
  - [Geo indexing]()
  - [Sorting, scoring, stemming]()

---

Client Libraries

#### Go
- [Trans/pipe examples]()
- [JSON queries]()

#### .NET
- [Vector search]()
- [Trans/pipe usage]()
- [JSON queries]()

#### Java (Jedis)
- [Vector search]()
- [Trans/pipe usage]()

#### Node.js
- [Vector queries]()
- [Trans/pipe examples]()
- [JSON queries]()

#### Redis-py
- [ScanIter usage]()
- [Vector search]()
- [Trans/pipe usage]()
- [JSON queries]()

#### Lettuce
- [Cluster connection]()
- [Production usage]()

#### Hiredis
- Full client guide:
  - [Overview]()
  - [Connect]()
  - [Issue commands]()
  - [Handle replies]()
  - [Transactions and pipelines]()

Q4 2024 (October - December) Updates

* Updated the RESP3 specification document to include the [attribute type]().
* Updates to the [key eviction]() page.
* Updates to the Redis Insight page related to its new Redis Search auto-completion [feature]().
* Restructured and added testable connection examples to the [client pages]().
* Added [Redis Open Source]() and [Redis Stack]() release notes.
* Added new [Redis for AI]() page.
* Added new [Predis (PHP client library)]() page.

Q3 2024 (July - September) Updates

* Updated the [RAG with Redis quick start guide]().
* Updates for [Redis Open Source version 7.4]().
* Added new [Redis Insight debugging]() page.
* Completed a major re-write/restructuring of the [vector indexing page]().
* Added new [client-side caching page]().
* Added new documentation for the [RDI in Redis Insight feature]().
* Added new documentation for the [Redis for VS Code feature]().
* Added multi-language code examples to Redis Search [query]() pages.
* Added client-side caching information to the [supported clients]() pages.
* Numerous changes to the [Redis client content]().


Redis feature sets

Content

A Redis feature set includes a specific Redis database version along with the advanced capabilities and data structures provided by compatible module versions.

To use a new feature introduced in a later feature set, you must upgrade the corresponding components according to the following table.

| Redis feature set | What's new |
|-------------------|------------|
| **Feature set version:** 8.6| See [here]()|
| **Feature set version:** 8.4| See [here]()|
| **Feature set version:** 8.2| See [here]()|
| **Feature set version:** 8.0| See [here]()|
| **Feature set version:** 7.4

**Component versions:**
[Redis 7.4]()
[Search 2.10]()
[JSON 2.8]()
[Time series 1.12]()
[Bloom 2.8]() | **Hash**:
- [Expiration of individual hash fields]().
 **Streams**:
- To start reading from the last stream message, use [`XREAD`]() with the new ID value `+`.
 **Time series**:
Insertion-filter for close samples.
 **JSON**:
- A fix to not duplicate `AOF` commands multiple times in [`JSON.MSET`]().
 **Probabilistic**:
- Returns an error if [`CMS.MERGE`]() results in an overflow or underflow.
 **Redis Search**:
- New `BFLOAT16` and `FLOAT16` vector data types, reducing memory consumed by vectors while preserving accuracy.
- Support for indexing empty and missing values and enhanced developer experience for queries with exact matching capabilities.
- You can match `TAG` fields without needing to escape special characters.
- Expanded geospatial search with new `INTERSECT` and `DISJOINT` operators, improved reporting of the memory consumed by the index, and exposed full-text scoring in aggregation pipelines. |
| **Feature set version:** 7.2

**Component versions:**
[Redis 7.2](https://raw.githubusercontent.com/redis/redis/7.2/00-RELEASENOTES)
[Search 2.8]()
[JSON 2.6]()
[Time series 1.10]()
[Bloom 2.6]()
[Gears 2.0](https://github.com/RedisGears/RedisGears/releases) | - Performance and resource utilization improvements, including significant memory and speed optimizations for lists, sets, and sorted sets.
**JSON**:
- New JSON commands: [`JSON.MERGE`]() and [`JSON.MSET`]().
**Redis Search:**
- [Geo polygon search]().
**Compatibility changes**:
- Redis 7.2 uses a new format (version 11) for RDB files, which is incompatible with older versions.
- Redis feature set 7.2 does not include [graph capabilities](https://redis.io/blog/redisgraph-eol/). |
| **Feature set version:** 6.2

**Component versions:**
[Redis 6.2](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES)
[Search 2.6]()
[JSON 2.4]()
[Time series 1.8]()
[Bloom 2.4]()
[Graph 2.10]() | **Time series**:
- Time series gap filling.
**JSON**:
- Improved JSON path parser.
**Probabilistic:**
- New probabilistic data structure t-digest.
**Redis Search:**
- Wildcard queries for `TEXT` and `TAG`.
- Suffix search.
- Multi-value indexing and queries.
**Graph**:
- New pathfinding algorithms for graphs. |


Open Source

Summary: Get started with Redis Open Source

Overview

Redis is an [in-memory data store]() used by millions of developers as a cache, [vector database](), [document database](), [streaming engine](), and message broker. Redis has built-in replication and different levels of [on-disk persistence](). It supports complex [data types]() (for example, strings, hashes, lists, sets, sorted sets, and JSON), with atomic operations defined on those data types.

Since 2009, the Redis open source project has inspired an enthusiastic and active community of users and contributors. The Redis core source repository is hosted under [https://github.com/redis/redis](https://github.com/redis/redis) along with many of the client libraries. See the [Redis Open Source]() page for more details and links.

You can install Redis from source or from an executable/distribution for your OS.

* Install Redis on Linux using [APT](), [RPM](), or [Snap]()
* [Install Redis on macOS]()
* [Run Redis on Windows using Docker]()
* [Run Redis on Docker]()
* [Install Redis from Source]()
* [Install Redis with Redis Stack and Redis Insight]()

Use cases

The following quick start guides will show you how to use Redis for the following specific purposes:

- [Data structure store]()
- [Document database]()
- [Vector database]()
- [AI agents and chatbots]()
- [Retrieval Augmented Generation (RAG) with Redis]()

Data integration tools, libraries, and frameworks

- [Client API libraries]()
- [Redis Data Integration]()
- [Redis vector library for Python]()
- [Redis Cloud with Amazon Bedrock]()
- [Object-mapping for .NET]()
- [Spring Data Redis for Java]()

You can find a complete list of integrations on the [integrations and frameworks hub]().

To learn more, refer to the [develop with Redis]() documentation.

Deployment options

You can deploy Redis with the following methods:

- As a service by using [Redis Cloud](), the fastest way to deploy Redis on your preferred cloud platform.
- By installing [Redis Enterprise Software]() in an on-premises data center or on Cloud infrastructure.
- On a variety Kubernetes distributions by using the [Redis Enterprise operator for Kubernetes]().

The following guides will help you to get started with your preferred deployment method.

Get started with **[Redis Cloud]()** by creating a database:

- The [Redis Cloud quick start]() helps you create a free database.  (Start here if you're new.)
- [Create an Essentials database]() with a memory limit up to 12 GB.
- [Create a Pro database]() that suits your workload and offers seamless scaling.

Install a **[Redis Enterprise Software]()** cluster:

- [Redis Enterprise on Linux quick start]()
- [Redis Enterprise on Docker quick start]()
- [Get started with Redis Enterprise's Active-Active feature]()
- [Install and upgrade Redis Enterprise]()

Leverage **[Redis Enterprise for Kubernetes]()** to simply deploy a Redis Enterprise cluster on Kubernetes:

- [Deploy Redis Enterprise for Kubernetes]()
- [Deploy Redis Enterprise for Kubernetes with OpenShift]()

To learn more, refer to the [Redis products]() documentation.

Provisioning and observability tools

- [Pulumi provider for Redis Cloud]()
- [Terraform provider for Redis Cloud]()
- [Prometheus and Grafana with Redis Cloud]()
- [Prometheus and Grafana with Redis Enterprise]()

You can find a complete list of integrations on the [libraries and tools hub]().


Glossary

Overview

<dl class="glossary">

<!---

--->

A, B {#letter-a}

Allows you to manage permissions based on key patterns.

More info: [redis.io/operate/oss_and_stack/management/security/acl](); [ACL wikipedia](https://en.wikipedia.org/wiki/Access-control_list); [Database access control](); [Update database ACLs](); [Role-based access control]()

Geo-distributed databases that span multiple [Redis Enterprise Software]() [clusters](). Active-Active databases, also known as conflict-free replicated databases (CRDB), depend on [multi-primary replication]() and [conflict-free replicated data types (CRDTs)]() to power a simple development experience for geo-distributed applications.

More info: [Active-Active geo-distributed Redis](), [Geo-distributed Active-Active Redis applications](), [Developing applications for Active-Active databases]()

A "member database" of a global [Active-Active database]() which is made up of its own master and replica [shards]() spanning a single [cluster]().

More info: [Active-Active database instances]()

Provides applications read-only access to replicas of the data set from different geographical locations. The Redis Enterprise implementation of active-passive [replication]() is called [Replica Of]().

More info: [Database replication](), [Replica Of]()

Each node runs a web server that is used to provide the user with access to the Redis Enterprise Software admin console (previously known as management UI). The admin console allows viewing and managing the entire [cluster](), so it does not matter which [node]() is used to access it.

More info: [Manage clusters]()

A piece of code that intercepts requests to the Kubernetes API server prior to persistence of the object.

More info: [Using Admission Controllers](https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/)

Log files that keep a record of data changes by writing to the end of a file. This happens with every write, or every second to allow data recovering the entire
dataset by replaying the append-only log from the beginning to the end.

More info: [Data Persistence](), [Data Persistence with Redis Enterprise Software]()

A probabilistic data structure that tests whether an element is a member of a set. False positive matches are possible, but false negatives are not. Bloom filters are space-efficient and provide fast membership testing.

More info: [Bloom filters](), [RedisBloom]()

C {#letter-c}

A distributed database is causally consistent if it maintains the same order of operations on a piece of data across all database copies.

More info: [Causal consistency wikipedia](https://en.wikipedia.org/wiki/Causal_consistency), [Causal consistency in an Active-Active database]()

Classless Inter-Domain Routing (CIDR) is a method to allocate and route IP addresses. A CIDR allowlist defines a range of IP addresses and permits connections to them.

More info: [CIDR wikipedia](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing), [Configure CIDR allowlist]()

Concurrency or updates and writes refer to more than events that happen at the same wall clock time across member [Active-Active databases](). Concurrent updates refer to the fact that updates happen in between sync events that catch up member Active-Active databases with updates that happened on other member Active-Active databases.

More info: [Developing applications for Active-Active databases](), [Conflict-free replicated data types (CRDT)]()

Consistency models describe the way a distributed system keeps replicated data consistent between copies.

More info: [Consistency models](https://en.wikipedia.org/wiki/Consistency_model)

A Redis Enterprise cluster is composed of identical nodes that are deployed within a data center or stretched across local availability zones.

More info: [Database clustering]()

An internally managed [Redis database]() that acts as a single repository for all [cluster]() metadata.

More info: [Redis Enterprise cluster architecture]()

A collection of Redis Enterprise services responsible for [provisioning](), [migration](), monitoring, [re-sharding](), [rebalancing](), de-provisioning, auto-scaling.

More info: [Redis Enterprise cluster architecture](), [Database operations]()

Conflict-free replicated databases (CRDB) are an alternate name for [Active-Active databases](#active-active).

Techniques used by Redis data types in Active-Active databases that handle conflicting concurrent writes across member Active-Active databases. The Redis Enterprise implementation of CRDT is called an Active-Active database (formerly known as CRDB).

More info: [CRDT info](), [Active-Active geo-distributed Redis](), [CRDT wikipedia](https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type)

Control loops that watch the state of your Kubernetes cluster and make or request changes where needed to move the current cluster state closer to the desired state.

More info: [Controllers](https://kubernetes.io/docs/concepts/architecture/controller/)

Extensions of the Kubernetes API that allow you to store and retrieve structured data. Custom resources let you extend Kubernetes capabilities without modifying the core Kubernetes code.

More info: [Custom Resources](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/)

A cluster-wide resource that specifies which settings can be configured via custom resource files. CRDs define the structure and validation rules for custom resources.

More info: [CustomResourceDefinition](https://kubernetes.io/docs/reference/glossary/?fundamental=true#term-CustomResourceDefinition), [Custom Resources](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/custom-resources/)

D - F {#letter-d}

Defines how excess data is handled when the [database]() exceeds the memory limit.

More info: [Data Eviction Policy](), [Redis Enterprise data eviction]()

A configuration approach where you specify the desired state of your system, and the system automatically makes the necessary changes to achieve that state.

More info: [Managing Kubernetes Objects Using Declarative Configuration](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/declarative-config/)

Features are marked as _deprecated_ when they're scheduled to be removed from our products, generally because they've been replaced by new features.

For details, see [obsolete](#obsolete).

Naming system for computers, services, or other resources connected to the Internet or a private network. It associates various information with domain names assigned to each of the participating entities.

More info: [DNS wikipedia](https://en.wikipedia.org/wiki/Domain_Name_System)

After updating data on one instance of a distributed database, the other database copies may have stale data for a short time while they sync. Eventual consistency means that the updated data will eventually be the same across all database copies.

More info: [Eventual consistency wikipedia](https://en.wikipedia.org/wiki/Eventual_consistency)

The automatic process of switching to a backup system when the primary system fails. In Redis Enterprise, failover promotes replica shards to primary when the original primary becomes unavailable.

More info: [High availability](), [Replica HA]()

A domain name that includes a list of domain labels to specify the exact location in the DNS.

More info: [FQDN wikipedia](https://en.wikipedia.org/wiki/Fully_qualified_domain_name)

Linux command to synchronize a file's in-core state with a storage device. Used in [data persistence]() operations.

More info: [`fsync` man page](https://man7.org/linux/man-pages/man2/fsync.2.html), [Data persistence]()

A search technique that examines all words in every stored document to find matches to search criteria. Redis provides full-text search capabilities through its Search and Query features.

More info: [Redis Search](), [Full-text search]()

G - J {#letter-g}

The process of creating data structures that improve the speed of data retrieval operations. Redis supports various types of indexing including secondary indexing, vector indexing, and full-text indexing.

More info: [Redis Search](), [Indexing concepts]()

JavaScript Object Notation (JSON) is a lightweight data-interchange format. Redis provides native JSON support through RedisJSON, allowing you to store, update, and retrieve JSON values.

More info: [JSON data type](), [RedisJSON]()

The result of a hash calculation used in [database clustering]() to determine which [shard]() stores a particular key.

More info: [Database clustering](), [Sharding]()

A part of the key that is used in the hash calculation to determine the [hash slot]() for [database clustering]().

More info: [Database clustering](), [Hash slots]()

High availability (HA) is a characteristic of distributed systems that keeps systems available for users for longer than normal periods of time. This is done by reducing single points of failure, increasing redundancy, and making recovering from failures easier.

More info: [Redis Enterprise durability and high availability](), [High availability wikipedia](https://en.wikipedia.org/wiki/High_availability)

An API object that manages external access to the services in a Kubernetes cluster, typically HTTP.

More info: [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/), [Ingress routing for Redis Enterprise for Kubernetes]()

K, L {#letter-k}

A command-line tool for communicating with a Kubernetes API server.

More info: [Overview of kubectl](https://kubernetes.io/docs/reference/kubectl/overview/)

A protocol for accessing and maintaining distributed directory services over an IP network, often used to authenticate users.

More info: [LDAP wikipedia](https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol), [LDAP authentication]()

The time delay between when a command is issued and when a response is received. Redis is designed for low latency, typically operating in the sub-millisecond range.

More info: [Latency monitoring](), [Latency diagnosis]()

M - O {#letter-m}

[Node]() that operates as the leader of a [cluster](). Also known as the primary node.

More info: [Redis Enterprise cluster architecture](), [High availability]()

Deciding when and where [shards]() will be moved if more network throughput, memory, or CPU resources are needed.

More info: [Database operations](), [Cluster management]()

Protocol that resolves hostnames to the IP addresses that do not include a local name server.

More info: [multicast DNS wikipedia](https://en.wikipedia.org/wiki/Multicast_DNS)

A Redis extension that adds new commands, data types, and capabilities to Redis. Redis Enterprise includes several modules like RedisJSON, RedisSearch, RedisTimeSeries, and RedisBloom.

More info: [Redis modules](), [Install modules]()

The process of observing and tracking the performance, health, and behavior of Redis databases, clusters, and nodes using metrics and alerts.

More info: [Monitoring with metrics and alerts](), [Metrics reference]()

Method of authenticating users with pieces of evidence of the user's identity. When MFA is enabled on Redis Cloud, users must enter their username, password, and an authentication code when logging in.

More info: [Multi-factor authentication]()

Also known as multi-master replication, Active-Active databases have multiple primary nodes (one on each participating cluster) to enable concurrent writes operations.

More info: [Multi-primary replication]()

An abstraction used by Kubernetes to support multiple virtual clusters on the same physical cluster.

More info: [Namespaces](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/)

When features are removed from our products, they're generally replaced by new features that provide a better experience, more functionality, improved security, and other benefits.

To provide a transition period, we mark older features as _deprecated_ when introducing replacement features.  This gives you time to adjust your deployments, apps, and processes to support the new features.  During this transition, the older features continue to work as a courtesy.

Eventually, older features are removed from the product.  When this happens, they're considered _obsolete_, partly because they can no longer be used.

For best results, we advise against relying on deprecated features for any length of time.

Operators are software extensions to Kubernetes that make use of custom resources to manage applications and their components.

More info: [operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/)

If a member [Active-Active database]() is in an out of memory situation, that member is marked "inconsistent" by Redis Enterprise Software, the member stops responding to user traffic, and the [syncer]() initiates full reconciliation with other peers in the Active-Active database.

More info: [Active-Active database troubleshooting](), [Memory management]()

P - Q {#letter-p}

The ability to store data permanently to disk so that it survives server restarts. Redis supports RDB snapshots and AOF (Append-Only File) persistence methods.

More info: [Data persistence](), [Redis Enterprise persistence]()

[Clusters]() participating in the [multi-primary replication]() of an [Active-Active database]().

More info: [Active-Active geo-distributed Redis](), [Create Active-Active database]()

A piece of storage in the cluster that has been provisioned by an administrator or dynamically provisioned using storage classes.

More info: [Persistent Volumes](https://kubernetes.io/docs/concepts/storage/persistent-volumes/)

A request for storage by a user that serves as an abstract representation of PersistentVolume (PV) resources. PVCs consume PV resources and can request specific size and access modes.

More info: [Persistent Volumes](https://kubernetes.io/docs/concepts/storage/persistent-volumes/)

The smallest deployable units of computing that you can create and manage in Kubernetes. A pod represents a single instance of a running process in your cluster.

More info: [Pods](https://kubernetes.io/docs/concepts/workloads/pods/)

Deciding where [shards]() will be created and placed within a [cluster]().

More info: [Database operations](), [Create databases]()

Determines the number and location of active proxies tied to a single endpoint that receive incoming traffic for a database.

For more info, see [Proxy policy]().

[Node]() provisioned only for [cluster]() operations that can be elected as a [master node](). The quorum node participates in the cluster quorum and must be explicitly assigned this role via the `rladmin` command.

More info: [Redis Enterprise cluster architecture](), [rladmin command reference]()

R {#letter-r}

A collection of Redis modules that extends Redis with modern data models and processing engines. Includes capabilities for document databases, graph databases, time series, and more.

More info: [Redis Stack](), [Redis Stack features]()

Redis Enterprise feature that helps to ensure high availability in the event of a rack or zone failure. In the event of a rack or zone failure, the replicas and endpoints in the remaining racks/zones will be promoted.

More info: [Rack-zone awareness in Redis Enterprise Software]()

[Databases]() using [replication]() or [Active-Active]() maintain a backlog to synchronize the primary and replica [shards]().

More info: [Database replication](), [Active-Active databases]()

Distributing keys and their values among new [shards]() to optimize performance and resource utilization.

More info: [Database clustering](), [Database operations]()

Moving [shards]() to [nodes]() where more resources are available.

More info: [Database operations](), [Cluster management]()

The cloud version of Redis Enterprise.

More info: [Redis Cloud](), [Redis Cloud quick start]()

Collection of [Redis Enterprise nodes](). A [cluster]() pools system resources across nodes in the cluster and supports multi-tenant [database]() instances.

More info: [Redis Enterprise cluster architecture](), [Cluster management]()

Logical entity that manages your entire dataset across multiple [Redis instances](). It segments the data into [shards]() and distributes them among [nodes]().

More info: [Database operations](), [Create databases]()

Physical or virtual machines or containers that runs a collection of Redis Enterprise services within a [cluster]().

More info: [Redis Enterprise cluster architecture](), [Install and setup]()

The on-premises version of Redis Enterprise.

More info: [Redis Enterprise Software](), [Install Redis Enterprise Software]()

Single-threaded Redis Open Source database. Redis OSS was renamed Redis Open Source with the Redis 8 in Redis Open Source release.

More info: [Redis Open Source](), [Database clustering]()

Previously known as Redis on Flash. Enables your Redis databases to span both RAM and dedicated flash memory (SSD). Auto Tiering manages the location of key values (RAM vs Flash) in the database via a LRU-based (least-recently-used) mechanism.

More info: [Auto Tiering](), [Auto Tiering  quick start]()

High availability feature of Redis Enterprise Software. After a node failure, the cluster automatically migrates remaining replica shards to available nodes. Previously known as "Slave HA" or `slave_ha`.

More info: [High availability for replica shards]()

The Redis Enterprise implementation of active-passive database replication.

More info: [Replica Of
]()

A ReplicaSet is a type of Kubernetes resource that (aims to) maintain a set of replica pods running at any given time.

More info: [ReplicaSet](https://kubernetes.io/docs/concepts/workloads/controllers/replicaset/)

Database replication provides a mechanism to ensure high availability. When replication is enabled, your dataset is replicated to a replica shard,
which is constantly synchronized with the primary shard. If the primary
shard fails, an automatic failover happens and the replica shard is promoted.

More info: [Database replication]()

Kubernetes objects that grant the permissions defined in a role to a user or set of users, including service accounts.

More info: [RoleBinding and ClusterRoleBinding](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#rolebinding-and-clusterrolebinding)

A security approach that restricts system access to authorized users.

More info: [RBAC wikipedia](https://en.wikipedia.org/wiki/Role-based_access_control); [Database access control](); [Role-based access control]()

Kubernetes objects that contain rules representing a set of permissions. Roles define what actions can be performed on which resources.

More info: [Role and ClusterRole](https://kubernetes.io/docs/reference/access-authn-authz/rbac/#role-and-clusterrole)

S {#letter-s}

The ability to query and retrieve data using various search methods including full-text search, vector search, and secondary indexing. Redis provides search capabilities through its Search and Query features.

More info: [Redis Search](), [RedisSearch]()

Creating additional data structures to enable fast lookups on fields other than the primary key. Redis supports secondary indexing for JSON documents, hashes, and other data types.

More info: [Redis Search](), [Indexing concepts]()

Kubernetes term for object that stores sensitive information, such as passwords, OAuth tokens, and ssh keys.

More info: [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/)

Provides an identity for processes that run in a pod, allowing them to access the Kubernetes API and other resources.

More info: [Service Accounts](https://kubernetes.io/docs/concepts/security/service-accounts/)

An abstract way to expose an application running on a set of pods as a network service in Kubernetes.

More info: [Services](https://kubernetes.io/docs/concepts/services-networking/service/)

Redis process that is part of the Redis clustered database.

More info: [Database clustering](), [terminology]()

Technique that has been used to scale larger data storage and processing loads. Sharding take your data, partitions it into smaller pieces and then send the data to different locations depending on which partition the data has been assigned to. Related to [hash slots]() and [shards]().

More info: [Database clustering](), [Shards]()

Framework for adding authentication support and data security to connection-based protocols via replaceable mechanisms.

More info: [SASL wikipedia](https://en.wikipedia.org/wiki/Simple_Authentication_and_Security_Layer)

Data persistence file that performs a data dump every one, six, or twelve hours. Used alongside [append-only file (AoF)]() for data persistence.

More info: [Data persistence](), [Append-only file (AoF)]()

A way for administrators to describe the classes of storage they offer in Kubernetes, including different quality-of-service levels, backup policies, or arbitrary policies.

More info: [Storage Classes](https://kubernetes.io/docs/concepts/storage/storage-classes/)

Process on each node hosting an Active-Active database instance that synchronizes a backlog of operations between participating clusters.

More info: [Syncer process]()

T - Z {#letter-t}

The number of operations or requests that can be processed per unit of time. Redis is designed for high throughput, capable of handling hundreds of thousands to millions of operations per second.

More info: [Redis benchmarks](), [Performance optimization]()

A sequence of data points indexed in time order. Redis provides native time series support through RedisTimeSeries for storing and querying time-stamped data.

More info: [Time series data type](), [RedisTimeSeries]()

A key that is logically deleted but stays in memory until it is collected by the garbage collector. Common in [Active-Active databases]() during conflict resolution.

More info: [Active-Active database development](), [Conflict-free replicated data types (CRDT)]()

Protocols that provide communications security over a computer network.

More info: [TLS wikipedia](https://en.wikipedia.org/wiki/Transport_Layer_Security), [Cloud database TLS](), [Redis Enterprise TLS]()

A search method that finds similar items by comparing high-dimensional vectors representing data features. Redis supports vector search for AI applications, machine learning, and similarity matching.

More info: [Vector search](), [Vector indexing]()

Networking connection between two VPCs that enables you to route traffic between them using private IP addresses. Instances in either VPC can communicate with each other as if they are within the same network.

More info: [VPC wikipedia](https://en.wikipedia.org/wiki/Virtual_private_cloud), [Enable VPC peering]()

</dl>


Create a Bedrock agent

Summary: Shows how to set up your Agent in Amazon Bedrock.

Overview

After you have [created a knowledge base](), you can use it to create an agent on Amazon Bedrock.

Before you begin this guide, you will need:

- An [AWS IAM Role](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) with [permissions for the Bedrock agent](https://docs.aws.amazon.com/bedrock/latest/userguide/security_iam_id-based-policy-examples.html).

- A [Bedrock knowledge base]() connected to a [Redis Cloud vector database]().

Create an agent

1. Sign in to the [AWS console](https://console.aws.amazon.com/).

1. Use the **Services** menu to locate and select **Machine Learning** > **Amazon Bedrock**.  This takes you to the Amazon Bedrock admin panel.

1. Select **Agents** > **Create Agent** to create your knowledge base.

1. In the **Agent name** section, enter a name and description for your agent.

1. Select whether or not you want the agent to be able to ask for additional information in the **User input** section.

1. Select the IAM role for the Bedrock agent in the **IAM Permissions** section.

1. Choose how long you want your idle session timeout to be in the **Idle session timeout** section. Select **Next** to continue.

1. In the **Model details** section, choose which model you want to use and enter the instructions for your agent. Select **Next** to continue.

1. In the **Action groups** section, you may specify any tasks you would like the agent to perform. Select **Next** to continue.

1. Select the [knowledge base](#create-a-knowledge-base) you created and summarize the information in the knowledge base in the **Knowledge base instructions for Agent** form. Select **Add another knowledge base** if you would like to add multiple knowledge bases.

    Select **Next** to continue.

1. Review your agent before you create it. Select **Create Agent** to finish creation.

Amazon Bedrock will create your agent and link it to your knowledge base. This will take some time.

Your agent will have a status of **Ready** when it is ready to be tested.

Select the name of your agent to view the versions and draft aliases of your agent. You can also test your agent by entering prompts in the **Enter your message here** field.


Create a Bedrock knowledge base

Summary: Shows how to set up your Knowledge base in Amazon Bedrock.

Overview

After you have set up a vector database with Redis Cloud, you can use it to create a knowledge base for your models.

Before you begin this guide, you will need:

- An [AWS S3 Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html) with text data that you want to use to train your models.

- An [AWS IAM Role](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) with permissions for the Bedrock knowledge base.

- A Redis database that is [set up for Amazon Bedrock]()

Create knowledge base

To use your Redis database to create a knowledge base on Amazon Bedrock:

1. Sign in to the [AWS console](https://console.aws.amazon.com/).

1. Use the **Services** menu to locate and select **Machine Learning** > **Amazon Bedrock**.  This takes you to the Amazon Bedrock admin panel.

1. Select **Knowledge base** > **Create knowledge base** to create your knowledge base.

1. In the **Knowledge base details** section, enter a name and description for your knowledge base.

1. Select the IAM role for the Bedrock knowledge base in the **IAM Permissions** section. Select **Next** to add the data source.

1. Enter a name for the data source and connect your S3 bucket in the **Data source** section.

1. In the **Vector database** section, select **Redis Cloud** and select the checkbox to agree with the legal disclaimer.

    Fill in the fields with the following information:

    - **Endpoint URL**: Public endpoint of your database. This can be found in the [Redis Cloud console](https://cloud.redis.io/) from the database list or from the **General** section of the **Configuration** tab for the source database.
    - **Credentials Secret ARN**: [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/reference_iam-permissions.html#iam-resources) of your [database credentials secret]().
    - **Vector Index name**: Name of the [vector index]()
    - **Vector field**: Name of the [vector field]() of the vector index
    - **Text field**: Name of the [text field]() of the vector index
    - **Metadata field**: Name of the [metadata field]() of the vector index

    Select **Next** to review your settings.

1. Review your knowledge base before you create it. Select **Create knowledge base** to finish creation.

Amazon Bedrock will sync the data from the S3 bucket and load it into your Redis database. This will take some time.

Your knowledge base will have a status of **Ready** when it is ready to be connected to an Agent.

Select the name of your knowledge base to view the syncing status of your data sources. The data source will have a status of **Ready** when it is synced to the vector database.

After the knowledge base is ready, you can use it to [Create an agent]().


Amazon Bedrock

Summary: Shows how to use your Redis database with Amazon Bedrock to customize foundational models.

Summary: Shows how to set up your Redis database for Amazon Bedrock.

Set up Redis for Bedrock

Create a Bedrock knowledge base

Create a Bedrock agent

Overview

[Amazon Bedrock](https://aws.amazon.com/bedrock/) streamlines GenAI deployment by offering foundational models (FMs) as a unified API, eliminating complex infrastructure management. It lets you create AI-powered [Agents](https://aws.amazon.com/bedrock/agents/) that execute complex tasks. Through [Knowledge Bases](https://aws.amazon.com/bedrock/knowledge-bases/) within Amazon Bedrock, you can seamlessly tether FMs to your proprietary data sources using retrieval-augmented generation (RAG). This direct integration amplifies the FM's intelligence based on your organization's resources.

Amazon Bedrock lets you choose Redis Cloud as the [vector database](https://redis.io/solutions/vector-search/) for your agent's Knowledge Base. Once Redis Cloud is integrated with Amazon Bedrock, it automatically reads text documents from your Amazon Simple Storage Service (S3) buckets. This process lets the large language model (LLM) pinpoint and extract pertinent context in response to user queries, ensuring your AI agents are well-informed and grounded in their responses.

For more information about the Redis integration with Amazon Bedrock, see the [Amazon Bedrock integration blog post](https://redis.io/blog/amazon-bedrock-integration-with-redis-enterprise/).

To fully set up Bedrock with Redis Cloud, you will need to do the following:

1. [Set up a Redis Cloud subscription and vector database]() for Bedrock.

1. [Create a knowledge base]() connected to your vector database.

1. [Create an agent]() connected to your knowledge base.

More info

- [Amazon Bedrock integration blog post](https://redis.io/blog/amazon-bedrock-integration-with-redis-enterprise/)
- [Detailed steps](https://github.com/redis-applied-ai/aws-redis-bedrock-stack/blob/main/README.md)


Set up Redis for Bedrock

Overview

You need to set up your Redis Cloud database before you can set it as the vector database in Amazon Bedrock. To do this, you need to:

1. [Sign up for Redis Cloud and create a database](#sign-up-create-subscription)
1. [Enable Transport Layer Security (TLS) for the database and save the certificates](#get-certs)
1. [Store database credentials in AWS secrets manager](#store-secret)
1. [Create a vector index in your database](#create-vector-index) for Bedrock to use

After you set up the database, you can use the database information to set it as your knowledge base database when you [create a knowledge base]().

Sign up and create a database  {#sign-up-create-subscription}

To set up a Redis Cloud instance for Bedrock, you need to:

1. [Sign up for Redis Cloud](#sign-up) if you do not already have an account.
1. [Create a database](#create-sub) to use for your Bedrock knowledge base.

Sign up for Redis Cloud using AWS Marketplace {#sign-up}

1.  Select the [Redis Cloud](https://aws.amazon.com/marketplace/pp/prodview-mwscixe4ujhkq?sr=0-1&ref_=beagle&applicationId=AWSMPContessa) AWS marketplace link from Bedrock to be taken to the Redis Cloud plan listing.

1.  Subscribe to Redis Cloud listing, locate the **Set Up Your Account** button, and then select it to begin mapping your Redis Cloud account with your AWS Marketplace account.

1.  Sign in to the [Redis Cloud console](https://cloud.redis.io).

1.  Select the Redis account to be mapped to your AWS Marketplace account and confirm that your payment method will change and that the connection cannot be undone.

1.  Use the **Map account** button to confirm your choice.

1.  Once your Redis account is mapped to your AWS Marketplace account, a message appears in the upper, left corner of the account panel.

    In addition, AWS Marketplace is reported as the selected payment method.

Create a database {#create-sub}

1. In the [Redis Cloud console](https://cloud.redis.io/), select **New database**.

1. When the **New database** page appears, select **Pro** to create a Pro plan.

1. After you select **Pro**, the **Database settings** section will appear. For this guide, continue with **Easy create** to get started faster.

    If you'd like to select all of the configuration options yourself, select **Custom settings**. See [Create a Redis Cloud Pro database]() for more details.

1. Redis will generate a database name for you. If you want to change it, you can do so in the **Database name** field.

1. Select **Amazon Web Services** as the cloud vendor and select a region.

1. In the **Database Sizing** section:

    - Select [**High availability**]() if it is not already selected.
    - Set the Dataset size of your database based on the amount of data that Bedrock will pull from your Simple Storage Service (S3) [bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html). See [Find out the size of your S3 buckets](https://aws.amazon.com/blogs/storage/find-out-the-size-of-your-amazon-s3-buckets/) to find out how much knowledge base data is stored in your S3 bucket and pick the closest size, rounded up, from the table below.

        | Total Size of Documents in S3 | Database size without replication | Database size with replication |
|-------------------------------|-----------------------------------|--------------------------------|
| 10,000 kb                     | 135 Mb                             | 270 Mb                         |
| 100,000 kb                    | 1.35 Gb                            | 2.7 Gb                         |
| 1,000,000 kb                  | 13.5 Gb                              | 27 Gb                          |
| 10,000,000 kb                 | 135 Gb                             | 270 Gb                         |

        For more information on sizing, see the [Bedrock integration blog post](https://redis.io/blog/amazon-bedrock-integration-with-redis-enterprise/#right-size-your-database-for-amazon-bedrock).

1. Select **View all settings** to review the database settings that we selected for you.

    If you want to change these settings, select [**Switch to custom settings**]().

1. You will not need to enter a payment method, as it's automatically assigned to your AWS Marketplace account. Select **Confirm & pay** to create your new database.

    Note that databases are created in the background.  While they are provisioning, you aren't allowed to make changes.  (The process generally takes 10-15 minutes.)

    Use the **Databases list** to check the status of your subscription.  You will also receive an email when your database is ready to use.

Enable TLS and get certificates {#get-certs}

For your database to be fully secure, you must enable [Transport Layer Security (TLS)]() for your database with client authentication.

1. Select **Databases** from the [Redis Cloud console](https://cloud.redis.io/) menu and then select your database from the list.

1. From the database's **Configuration** screen, select the **Edit** button:

1. In the **Security** section, use the **Transport layer security (TLS)** toggle to enable TLS:

1. Select **Download server certificate** to download the Redis Cloud certificate bundle `redis_ca.pem`:

1. Select the **Mutual TLS (require client authentication)** checkbox to require client authentication.

1. Select **Add client certificate** to add a certificate.

1. Either provide an [X.509 client certificate](https://en.wikipedia.org/wiki/X.509) or chain in PEM format for your client or select **Generate** to create one:

    - If you generate your certificate from the Redis Cloud console, a **Download certificate** button will appear after it is generated. Select it to download the certificate.

        The download contains:

        - `redis-db-<database_id>.crt` – the certificate's public key.

        - `redis-db-<database_id>.key` – the certificate's private key.

You must download the certificate using the button at this point.  After your changes have been applied, the full bundle of public and private keys will no longer be available for download.

    - If you provide a client certificate, you will see the certificate details before you save your changes.

1. To apply your changes and enable TLS, select the **Save database** button:

Store database credentials in AWS secrets manager {#store-secret}

In the [AWS Management Console](https://console.aws.amazon.com/), use the **Services** menu to locate and select **Security, Identity, and Compliance** > **Secrets Manager**. [Create a secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) of type **Other type of secret** with the following key/value fields:

- `username`: Database username
- `password`: Database password
- `serverCertificate`: Contents of the [server certificate]() (`redis_ca.pem`)
- `clientCertificate`: Contents of the client certificate (`redis_user.crt`)
- `clientPrivateKey`: Contents of the client private key (`redis_user_private.key`)

After you store this secret, you can view and copy the [Amazon Resource Name (ARN)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/reference_iam-permissions.html#iam-resources) of your secret on the secret details page.

Create a vector index in your database {#create-vector-index}

After your Redis Cloud database is set up, create a search index with a vector field using [FT.CREATE]() as your knowledge base for Amazon Bedrock. You can accomplish this using **Redis Insight** or `redis-cli`.

Redis Insight

[Redis Insight]() is a free Redis GUI that allows you to visualize and optimize your data in Redis.

To create your vector index in Redis Insight:

1. [Download and install Redis Insight](https://redis.io/insight/) if you don't have it already.

1. In the [Redis Cloud console](https://cloud.redis.io/), in your database's **Configuration** tab, select the **Connect** button next to your database to open the connection wizard.

1. In the connection wizard, under **Redis Insight Desktop**, select **Public Endpoint**. Select **Open with Redis Insight** to connect to the database with Redis Insight.

1. Select **Use TLS**. In the **CA Certificate** section, select **Add new CA certificate**. Give the certificate a name in the **Name** field, and enter the contents of `redis_ca.pem` into the **Certificate** field.

1. Select **Requires TLS Client Authentication**. In the **Client Certificate** section, select **Add new certificate**. Give the certificate a name in the **Name** field. Enter the contents of `redis_user.crt` into the **Certificate** field, and the contents of `redis_user_private.key` into the **Private Key** field.

1. Select **Add Redis Database** to connect to the database.

1. Select your database alias to connect to your database. Select the **Workbench** icon to go to the workbench.

1. Enter the [FT.CREATE]() command to create an index.

    [code example]

    Replace the following fields:

    - `<index_name>` with the vector index name
    - `<text_field>` with the text field name
    - `<metadata_field>` with the metadata field name
    - `<vector_field>` with the vector field name

1. Select **Run** to create the index.

`redis-cli`

The [`redis-cli`]() command-line utility lets you connect and run Redis commands directly from the command line. To use `redis-cli`, you can [install Redis]().

Public endpoint and port details are available from the **Databases** list or the database's **Configuration** screen. Select **Connect** to view how to connect to your database with `redis-cli`.

[code example]

After you are connected with `redis-cli`, create an index using [FT.CREATE]().

[code example]

Replace the following fields:
- `<index_name>` with the vector index name
- `<text_field>` with the text field name
- `<metadata_field>` with the metadata field name
- `<vector_field>` with the vector field name

Next steps

After your Redis database is set up, you can use it to [create a knowledge base]() in Amazon Bedrock.

FT.CREATE <index_name>
        ON HASH
        SCHEMA
            "<text_field>" TEXT
            "<metadata_field>" TEXT
            "<vector_field>"  VECTOR FLAT
                6
                "TYPE" "FLOAT32"
                "DIM" 1536
                "DISTANCE_METRIC" "COSINE"

redis-cli -h <endpoint> -p <port> --tls --cacert redis_ca.pem \
    --cert redis_user.crt --key redis_user_private.key


Redis Cloud on AWS

Overview

Deploy Redis Cloud on Amazon Web Services (AWS) to leverage Redis's performance with AWS's global infrastructure and services.

Overview

Redis Cloud on AWS provides a fully managed Redis service that combines the power of Redis with AWS's reliable, scalable cloud infrastructure. Deploy Redis databases across multiple AWS regions with enterprise-grade security, automatic scaling, and 24/7 monitoring.

Key Features

- **VPC Peering**: Secure, private connectivity between Redis Cloud and your AWS VPC
- **AWS Transit Gateway**: Private connectivity to multiple resources
- **Multi-AZ Deployment**: High availability across AWS Availability Zones
- **AWS Marketplace**: Simple billing through your existing AWS account
- **Global Distribution**: Deploy in 12+ AWS regions worldwide
- **Auto-scaling**: Automatic scaling based on memory usage and throughput
- **Enterprise Security**: Data encryption, compliance certifications, and access control
- **24/7 Monitoring**: Comprehensive monitoring and alerting capabilities

Getting Started

Get started with [Redis Cloud]() on AWS to create and manage your Redis databases with step-by-step setup instructions and best practices.


Redis Cloud on Azure

Summary: Deploy Redis Cloud on Microsoft Azure

Overview

Deploy Redis Cloud on Microsoft Azure to combine Redis's high performance with Azure's enterprise-grade cloud platform and services.

Overview

Redis Cloud on Azure provides a fully managed Redis service that integrates seamlessly with Azure's enterprise cloud platform. Deploy Redis databases across multiple Azure regions with enterprise-grade security, compliance, and Azure-native integrations.

Regions

Redis Cloud Essentials is available on multiple Microsoft Azure regions, see [Supported regions]().

Getting Started

Get started with [Redis Cloud]() to create and manage your Redis databases.


Confluent with Redis Cloud

Summary: Describes how to integrate Redis Cloud into Confluent Cloud.

Overview

You can send data from [Confluent Cloud](https://confluent.cloud/) to your Redis Cloud database using the [Redis Sink connector for Confluent Cloud](https://docs.confluent.io/cloud/current/connectors/cc-redis-sink.html).

Prerequisites

Before you add the Redis Sink Confluent connector to your Confluent Cloud cluster:

1. [Create a database]() in the same region as your Confluent Cloud cluster.

1. If you decide to [enable Transport Layer Security (TLS)]() for your Redis database, [download the server certificate]() from the Redis Cloud console and [encode it](#encode-server-certificate) to be used with Confluent Cloud.

1. Ensure you meet the prerequisites in the [Redis Sink connector documentation](https://docs.confluent.io/cloud/current/connectors/cc-redis-sink.html#quick-start) to set up your Redis Sink with Confluent Cloud.

Encode server certificate

If you decide to enable Transport Layer Security (TLS) for your database, you will need to encode the [server certificate]() (`redis_ca.pem`) for use as the Confluent Cloud Truststore file. To do this:

1. Use a base64 utility to encode `redis_ca.pem` into base64 in a new file. For example, using the [`base64` command-line utility](https://linux.die.net/man/1/base64):

    [code example]

1. Using a text editor, add the following text to the beginning of the truststore file:

    [code example]

1. Save and close the truststore file.

Connect the Redis Sink connector to Redis Cloud

To add the Redis Sink connector to your Confluent Cloud environment from the Redis Cloud console:

1. From the [Redis Cloud console](https://cloud.redis.io/), select **Account Settings** and then select the **Integrations** tab.

1. Select the **Configure** button in the **Confluent** tile.

1. This will take you to [New Sink Connector](https://confluent.cloud/go/new-sink-connector/RedisSink) on Confluent Cloud. If you have more than one Confluent Cloud environment or Cluster, select your environment and cluster from the lists and select **Continue**.

1. From there, follow the steps to [Enter the connector details](https://docs.confluent.io/cloud/current/connectors/cc-redis-sink.html#step-4-enter-the-connector-details) on the Confluent documentation.

    When you get to the **Authentication** step, fill in the fields with the following information:

    - **Redis hostname**: The Public endpoint of your database, without the port number. This can be found in the [Redis Cloud console](https://cloud.redis.io/) from the database list or from the **General** section of the **Configuration** tab for the source database.
    - **Redis port number**: The database's port. This is the number at the end of your database's Public endpoint.
    - **Redis database index**: Set this to 0 for a Redis Cloud database.
    - **Redis server password**: Enter the database password. If you have not set your own database user and password, use the [default user password](), which appears in the **Security** section of the **Configuration** tab of the database details screen.
    - **SSL mode**: Set depending on what type of [TLS authentication]() is set for your database.
        - If TLS authentication is turned off, select **disabled**.
        - If TLS authentication is turned on, select **server**.
    - **Trustore file**: If the **SSL mode** is set to **server**, upload the truststore file created when you [encoded the server certificate](#encode-server-certificate).
    - **Redis Server mode**: If [OSS Cluster API]() is enabled, select **Cluster**. Otherwise, select **Standalone**.

    Select **Continue** once you have entered the database information. Enter the rest of the [connector details](https://docs.confluent.io/cloud/current/connectors/cc-redis-sink.html#step-4-enter-the-connector-details) from the **Configuration** step.

1. [Connect to your database]() to verify that data is being stored.

$ base64 -i redis_ca.pem -o <truststore_file_name>


Datadog with Redis Cloud

Summary: To collect, view, and monitor metrics data from your databases and other cluster components, you can connect Datadog to your Redis Cloud cluster using the Redis Datadog Integration.

Overview

[Datadog](https://www.datadoghq.com/) is used by organizations of all sizes and across a wide range of industries to
enable digital transformation and cloud migration, drive collaboration among development, operations, security and
business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and
infrastructure, understand user behavior, and track key business metrics.

The Datadog Integration for Redis Cloud uses the Datadog Integration API to connect to Redis metrics exporters.
The integration is based on Datadog's
[OpenMetrics integration](https://datadoghq.dev/integrations-core/base/openmetrics/) in their core API. This integration
enables Redis Cloud users to export metrics directly to Datadog for analysis, and includes Redis-designed
dashboards for use in monitoring Redis Cloud clusters.

This integration makes it possible to:
- Collect and display metrics not available in the admin console
- Set up automatic alerts for node or cluster events
- Display these metrics alongside data from other systems

Install Redis' Datadog Integration for Redis Cloud

Installing the Datadog integration is a two-step process. Firstly, the installation must be part of your configuration.
Select 'Integrations' from the menu in the Datadog portal and then enter 'Redis' in the search bar, then select
'Redis Cloud by Redis, Inc.'. Next click 'Install Integration' in the top-right corner of the overview page.

If you have not already created a VPC between the Redis Cloud cluster and the network in which the machine hosting the
Datadog agent lives you should do so now. Please visit [VPC Peering](https://redis.io/docs/latest/operate/rc/security/vpc-peering/)
and follow the instructions for the cloud platform of your choice.

Returning to the Datadog console, open the 'Configure' tab of the integration and follow the instructions for installing
the integration on the local machine. After it has been installed follow the instruction for adding an instance to the
conf.yaml in /etc/datadog-agent/conf.d/redis_cloud.d.

After you have edited the conf.yaml file please restart the service and check its status:

[code example]

followed by:

[code example]

to be certain that the service itself is running and did not encounter any problems. Next, check the output of the
service; in the terminal on the Datadog agent host run the following command:

[code example]

It will take several minutes for data to reach Datadog. Finally, check the Datadog console by selecting
Infrastructure -> Host Map from the menu and then finding the host that is monitoring the Redis Cloud instance. The host
should be present, and in its list of components there should be a section called 'rdsc', which is the namespace used by
the Redis Cloud integration, although this can take several minutes to appear. It is also possible to verify the metrics
by choosing Metrics -> Explorer from the menu and entering 'rdsc.bdb_up'.

View metrics

The Redis Cloud Integration for Datadog contains pre-defined dashboards to aid in monitoring your Redis Cloud deployment.

The following dashboards are currently available:

- Overview
- Database
- Network

A number of additional dashboards will be included in the next release (v1.1.0).

Monitor metrics

See [Observability and monitoring guidance]() for monitoring details.


Datadog with Redis Software

Summary: To collect, view, and monitor metrics data from your databases and other cluster components, you can connect Datadog to your Redis Software cluster using the Redis Datadog Integration.

Overview

[Datadog](https://www.datadoghq.com/) is used by organizations of all sizes and across a wide range of industries to
enable digital transformation and cloud migration, drive collaboration among development, operations, security and
business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and
infrastructure, understand user behavior, and track key business metrics.

The Datadog Integration for Redis Software uses Datadog's Integration API to connect to Redis metrics exporters.
The integration is based on the Datadog
[OpenMetrics integration](https://datadoghq.dev/integrations-core/base/openmetrics/) in their core API. This integration
enables Redis Software users to export metrics directly to Datadog for analysis, and includes Redis-designed
dashboards for use in monitoring Redis Software clusters.

This integration makes it possible to:
- Collect and display metrics not available in the admin console
- Set up automatic alerts for node or cluster events
- Display these metrics alongside data from other systems

Install Redis' Datadog Integration for Redis Software

Installing the Datadog integration is a two-step process. Firstly, the installation must be part of your configuration.
Select 'Integrations' from the menu  in the Datadog portal and then enter 'Redis' in the search bar, then select
'Redis Software by Redis, Inc.'. Next click 'Install Integration' in the top-right corner of the overview page.
Once it has been installed follow the instructions for adding an instance to the conf.yaml in
/etc/datadog-agent/conf.d/redis_cloud.d.

After you have edited the conf.yaml file please restart the service and check its status:

[code example]

followed by:

[code example]

to be certain that the service itself is running and did not encounter any problems. Next, check the output of the
service; in the terminal on the Datadog agent host run the following command:

[code example]

It will take several minutes for data to reach Datadog. Finally, check the Datadog console by selecting
Infrastructure -> Host Map from the menu and then finding the host that is monitoring the Redis Software instance. The host
should be present, and in its list of components there should be a section called 'rdse', which is the namespace used by
the Redis Software integration, although this can take several minutes to appear. It is also possible to verify the metrics
by choosing Metrics -> Explorer from the menu and entering 'rdse.bdb_up'.

View metrics

The Redis Software Integration for Datadog contains pre-defined dashboards to aid in monitoring your Redis Software deployment.

The following dashboards are currently available:

- Overview
- Database
- Node
- Shard
- Active-Active
- Proxy
- Proxy Threads

Monitor metrics


Redis Software with Docker

Summary: Run Redis Software in Docker containers

Overview

Deploy Redis Software using Docker containers for quick development setups and testing environments.

Overview

Redis Software with Docker provides a containerized version of Redis Software, perfect for development, testing, and proof-of-concept deployments. Get enterprise features like clustering, high availability, and advanced security in a simple Docker container.

Key Features

- **Enterprise Features**: Full Redis Software capabilities in a container
- **Multi-tenancy**: Multiple databases with resource isolation
- **High Availability**: Built-in clustering and automatic failover
- **Advanced Security**: Role-based access control and encryption
- **Monitoring Dashboard**: Web-based management interface
- **Advanced capability support**: JSON, time series, and probabilistic data structures, and Redis Search.
- **Easy Setup**: Quick deployment with Docker Compose or single container
- **Development Ready**: Perfect for local development and testing environments

Getting Started

Get started with the [Redis Software Docker quickstart]() guide.


Dynatrace with Redis Cloud

Summary: To collect, view, and monitor metrics data from your databases and other cluster components, you can connect Dynatrace to your Redis Cloud cluster using the Redis Dynatrace Integration.

Overview

[Dynatrace](https://www.dynatrace.com/) is used by organizations of all sizes and across a wide range of industries to
enable digital transformation and cloud migration, drive collaboration among development, operations, security and
business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and
infrastructure, understand user behavior, and track key business metrics.

The Redis Dynatrace Integration for Redis Cloud uses Prometheus remote write functionality to connect Prometheus data
sources to Dynatrace. This integration enables Redis Cloud users to export metrics to Dynatrace for analysis,
and includes Redis-designed dashboards for use in monitoring Redis Cloud clusters.

This integration makes it possible to:
- Collect and display metrics not available in the admin console
- Set up automatic alerts for node or cluster events
- Display these metrics alongside data from other systems

Install Redis' Dynatrace Integration for Redis Cloud

The Dynatrace Integration is based on a feature of the Prometheus data source. Prometheus can forward metrics on to
another destination using remote writes. This will require a Prometheus installation inside the same datacenter as the
Redis Cloud deployment.

If you have not already created a VPC between the Redis Cloud cluster and the network in which the machine hosting
Prometheus lives you should do so now. Please visit [VPC Peering](https://redis.io/docs/latest/operate/rc/security/vpc-peering/)
and follow the instructions for the cloud platform of your choice.

View metrics

The Redis Cloud Integration for Dynatrace contains pre-defined dashboards to aid in monitoring your Redis Software deployment.

The following dashboards are currently available:

- Cluster: top-level statistics indicating the general health of the cluster
- Database: performance metrics at the database level
- Shard: low-level details of an individual shard
- Active-Active: replication and performance for geo-replicated clusters
- Proxy: network and command information regarding the proxy
- Proxy Threads: processor usage information regarding the proxy's component threads

Monitor metrics

Dynatrace dashboards can be filtered using the text area. For example, when viewing a cluster dashboard it is possible
filter the display to show data for only one cluster by typing 'cluster' in the text area and waiting for the system to
retrieve the relevant data before choosing one of the options in the 'cluster' section.

Certain types of data do not know the name of the database from which they were drawn. The dashboard should have a list
of database names and ids; use the id value when filtering input to the dashboard.


Dynatrace with Redis Software

Summary: To collect, view, and monitor metrics data from your databases and other cluster components, you can connect Dynatrace to your Redis Software cluster using the Redis Dynatrace Integration.

Overview

[Dynatrace](https://www.dynatrace.com/) is used by organizations of all sizes and across a wide range of industries to
enable digital transformation and cloud migration, drive collaboration among development, operations, security and
business teams, accelerate time to market for applications, reduce time to problem resolution, secure applications and
infrastructure, understand user behavior, and track key business metrics.

The Dynatrace Integration for Redis Software uses Prometheus remote write functionality to connect Prometheus data
sources to Dynatrace. This integration enables Redis Software users to export metrics to Dynatrace for analysis,
and includes Redis-designed dashboards for use in monitoring Redis Software clusters.

This integration makes it possible to:
- Collect and display metrics not available in the admin console
- Set up automatic alerts for node or cluster events
- Display these metrics alongside data from other systems

Install Redis' Dynatrace Integration for Redis Software

At the present time the Dynatrace integration is not signed by Dynatrace, meaning that it will be necessary to download
the source configuration and dashboards and assemble them and sign them cryptologically with a certificate that you have
created. The instructions for this procedure can be found on the Dynatrace
[site](https://docs.dynatrace.com/docs/extend-dynatrace/extensions20/sign-extension). Please note that the instructions
would have you place the dashboards next to the src folder; this is incorrect, the dashboards should be located inside
the src folder.

View metrics

The Redis Software Integration for Dynatrace contains pre-defined dashboards to aid in monitoring your Redis Software deployment.

The following dashboards are currently available:

- Cluster: top-level statistics indicating the general health of the cluster
- Database: performance metrics at the database level
- Node: machine performance statistics
- Shard: low-level details of an individual shard
- Active-Active: replication and performance for geo-replicated clusters
- Proxy: network and command information regarding the proxy
- Proxy Threads: processor usage information regarding the proxy's component threads

Monitor metrics

Dynatrace dashboards can be filtered using the text area. For example, when viewing a cluster dashboard it is possible to
filter the display to show data for only one cluster by typing 'cluster' in the text area and waiting for the system to
retrieve the relevant data before choosing one of the options in the 'cluster' section.

Certain types of data do not know the name of the database from which they were drawn. The dashboard should have a list
of database names and ids; use the id value when filtering input to the dashboard.


FusionCache for C#/.NET

Summary: Easy to use, fast and robust hybrid cache with advanced resiliency features for C#/.NET

Overview

FusionCache can transparently handle multiple cache levels by mixing a memory cache and a distributed cache together, getting the best of both worlds. It allows for a sophisticated yet incredibly easy to use developer experience by handling all the complexities of a modern, fast and robust hybrid cache that can deal with the most complex and demanding scenarios. When coupled with Redis, performance, robustness and scaling will not be a problem anymore.

Key Features

- **Hybrid**: Can be used as both L1 (memory only) or L1+L2 (memory + distributed)
- **Tagging**: Powerful tagging capabilities to easily work with multiple entries at once
- **Backplane**: For instant multi-node distributed notifications
- **Stampede Protection**: Both on single node (with a memory locker) and multi-node (with a distributed locker)
- **Redis Perfect Match**: Native support for all distributed parts (cache, backplane and locker)
- **Resiliency**: Fully resilient thanks to features like Fail-Safe, Eager Refresh, Factory Timeouts, Auto-Recovery and more
- **Sync+Async**: Full support for both programming models
- **.NET Ecosystem**: Seamless integration with ASP.NET Core, Entity Framework, and other .NET technologies

Install

Using the dotnet CLI, run:

[code example]

Other packages are also available to work with different distributed caches, serializers, backplanes and more.
See the [FusionCache docs](https://github.com/ZiggyCreatures/FusionCache/blob/main/docs/README.md) for more information.

Getting Started

First, install the packages for Redis (with JSON serialization):

[code example]

Then at startup:

[code example]

Use code like the following to share the Redis connection multiplexer:

[code example]

FusionCache is now ready to use. The simple example below demonstrates the `GetOrSetAsync` method but see [Core Methods](https://github.com/ZiggyCreatures/FusionCache/blob/main/docs/CoreMethods.md) in the FusionCache docs for full details of the API.

[code example]

Further Reading

To learn more about FusionCache and its advanced features:

- [FusionCache Documentation](https://github.com/ZiggyCreatures/FusionCache)
- [FusionCache NuGet Package](https://www.nuget.org/packages/ZiggyCreatures.FusionCache)
- [Redis Backplane Package](https://www.nuget.org/packages/ZiggyCreatures.FusionCache.Backplane.StackExchangeRedis)

dotnet add package ZiggyCreatures.FusionCache
dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis
dotnet add package ZiggyCreatures.FusionCache.Serialization.SystemTextJson
dotnet add package ZiggyCreatures.FusionCache.Backplane.StackExchangeRedis

services.AddFusionCache()
    .WithSerializer(
        new FusionCacheSystemTextJsonSerializer()
    )
    .WithDistributedCache(
        new RedisCache(new RedisCacheOptions { Configuration = "localhost:6379" })
    )
    .WithBackplane(
        new RedisBackplane(new RedisBackplaneOptions { Configuration = "localhost:6379" })
    );

var muxer = ConnectionMultiplexer.Connect("localhost:6379")

services.AddFusionCache()
    .WithSerializer(
        new FusionCacheSystemTextJsonSerializer()
    )
    .WithDistributedCache(
        new RedisCache(new RedisCacheOptions { ConnectionMultiplexerFactory = () => muxer })
    )
    .WithBackplane(
        new RedisBackplane(new RedisBackplaneOptions { ConnectionMultiplexerFactory = () => muxer })
    );

var product1 = await cache.GetOrSetAsync<Product>(
    "product:1",
    async _ => GetProductFromDb(1),
    tags: ["sales", "product"]
);

var product2 = await cache.GetOrSetAsync<Product>(
    "product:2",
    async _ => GetProductFromDb(2),
    tags: ["sales", "product"]
);

var order = await cache.GetOrSetAsync<Order>(
    "order:42",
    async _ => GetOrderFromDb(42),
    tags: ["sales", "order"]
);

// LATER...

await cache.RemoveByTagAsync("product");

// NOW BOTH product:1 AND product:2 ARE GONE, ONLY order:42 IS STILL IN THE CACHE


Redis Cloud on Google Cloud

Overview

Deploy Redis Cloud on Google Cloud Platform (GCP) to leverage Redis's performance with Google's scalable cloud infrastructure and AI/ML services.

Overview

Redis Cloud on Google Cloud provides a fully managed Redis service that integrates with Google's advanced cloud platform and AI/ML services. Deploy Redis databases across Google's global network with enterprise security, automatic scaling, and seamless GCP integrations.

Key Features

- **Private Service Connect**: Secure, private connectivity within Google Cloud
- **Global Network**: Deploy across Google's worldwide network of regions
- **Auto-scaling**: Intelligent scaling based on traffic patterns and usage
- **Enterprise Security**: Google Cloud IAM integration and advanced security features

Getting Started

Get started with [Redis Cloud]() on Google Cloud to create and manage your Redis databases.


Go client for Redis

Summary: Learn how to build with Redis and Go

Overview

Connect your Go application to a Redis database using the go-redis client library.

Overview

go-redis is a type-safe, Redis client library for Go that supports Redis 6.0+ features including Redis Cluster, Redis Sentinel, and Redis streams. It provides a clean, idiomatic Go API for interacting with Redis.

Key Features

- **Type Safety**: Strongly typed commands and responses
- **Redis Cluster Support**: Built-in support for Redis Cluster deployments
- **Redis Sentinel**: Automatic failover with Redis Sentinel
- **Pipelining**: Efficient command batching for improved performance
- **Pub/Sub**: Real-time messaging with Redis Pub/Sub
- **Streams**: Support for Redis Streams data structure
- **Connection Pooling**: Automatic connection management
- **Context Support**: Full context.Context integration for cancellation and timeouts

Getting Started

Refer to the complete [Go guide]() to install, connect, and use go-redis with detailed examples and best practices.


Redis Cloud on Heroku

Summary: Deploy Redis Cloud as a Heroku add-on