diff --git a/assets/css/index.css b/assets/css/index.css index f853ee80a0..ec86e95f8b 100644 --- a/assets/css/index.css +++ b/assets/css/index.css @@ -969,4 +969,103 @@ code { /* no-click turns off border and click event on small icons */ a[href*="#no-click"], img[src*="#no-click"] { @apply border-none cursor-default pointer-events-none no-underline; +} + +/* Version selector in side menu */ +.menu__version-selector { + float: right; + left: 18px; + padding: 0 22px 0; + position: relative; + top: -28px; + z-index: 1; + border: 1px solid #dfdfdf; +} + +.menu__version-selector button { + background: transparent; + border: none; + font-size: 13px; + outline: none; +} + +.menu__version-selector button span.menu__version-selector__toggler { + display: none; + font-size: 8px; + transform: translateY(-1px) translateX(2px); +} + +.menu__version-selector span.menu__version-selector__toggler.opener { + display: inline-block; +} + +.menu__version-selector span.menu__version-selector__toggler.closer { + display: none; +} + +.menu__version-selector .menu__version-selector__list { + background: #f7f7f7; + border: 1px solid #dfdfdf; + border-top: none; + display: none; + font-size: 13px; + left: -1px; + position: absolute; + width: calc(100% + 2px); + z-index: 1; +} + +.menu__version-selector .menu__version-selector__list a { + color: #868484; + display: block; + padding-left: 10px; + width: 100%; +} + +.menu__version-selector .menu__version-selector__list a:hover { + color: #000; +} + +.menu__version-selector .menu__version-selector__list a.selected-version { + display: none; +} + +.menu__version-selector.open { + border: 1px solid #dfdfdf; +} + +.menu__version-selector.open .menu__version-selector__toggler.opener { + display: none; +} + +.menu__version-selector.open .menu__version-selector__toggler.closer { + display: inline-block; +} + +.menu__version-selector.open .menu__version-selector__list { + display: block; +} + +.menu__version-selector > li .menu-divider { + border-top: 1px solid #5d6876; + height: 1px; + left: 20px; + margin-left: 0 !important; + position: absolute; + top: 10px; + width: calc(100% - 20px); +} + +.menu__version-selector > li > .children { + display: none; +} + +.menu__version-selector > li.parent > .children { + display: flex; + position: relative; + padding-top: 60px; +} + +.dd-item .highlight:hover { + color: #5961ff; } \ No newline at end of file diff --git a/content/commands/flushall/index.md b/content/commands/flushall/index.md index fe10a95fbe..e134d20363 100644 --- a/content/commands/flushall/index.md +++ b/content/commands/flushall/index.md @@ -62,8 +62,11 @@ It is possible to use one of the following modifiers to dictate the flushing mod * `ASYNC`: flushes the databases asynchronously * `SYNC`: flushes the databases synchronously -Note: an asynchronous `FLUSHALL` command only deletes keys that were present at the time the command was invoked. Keys created during an asynchronous flush will be unaffected. +## Notes + +* An asynchronous `FLUSHALL` command only deletes keys that were present at the time the command was invoked. Keys created during an asynchronous flush will be unaffected. +* This command does not delete functions. ## Behavior change history -* `>= 6.2.0`: Default flush behavior now configurable by the **lazyfree-lazy-user-flush** configuration directive. \ No newline at end of file +* `>= 6.2.0`: Default flush behavior now configurable by the **lazyfree-lazy-user-flush** configuration directive. diff --git a/content/commands/flushdb/index.md b/content/commands/flushdb/index.md index b87dd3fd79..6ca651c7a0 100644 --- a/content/commands/flushdb/index.md +++ b/content/commands/flushdb/index.md @@ -62,8 +62,11 @@ It is possible to use one of the following modifiers to dictate the flushing mod * `ASYNC`: flushes the database asynchronously * `SYNC`: flushes the database synchronously -Note: an asynchronous `FLUSHDB` command only deletes keys that were present at the time the command was invoked. Keys created during an asynchronous flush will be unaffected. +## Notes + +* An asynchronous `FLUSHDB` command only deletes keys that were present at the time the command was invoked. Keys created during an asynchronous flush will be unaffected. +* This command does not delete functions. ## Behavior change history -* `>= 6.2.0`: Default flush behavior now configurable by the **lazyfree-lazy-user-flush** configuration directive. \ No newline at end of file +* `>= 6.2.0`: Default flush behavior now configurable by the **lazyfree-lazy-user-flush** configuration directive. diff --git a/content/develop/connect/clients/go.md b/content/develop/connect/clients/go.md index 875f9e9688..9e65e4dac8 100644 --- a/content/develop/connect/clients/go.md +++ b/content/develop/connect/clients/go.md @@ -15,30 +15,33 @@ title: Go guide weight: 5 --- -Install Redis and the Redis client, then connect your Go application to a Redis database. +[`go-redis`](https://github.com/redis/go-redis) is the [Go](https://go.dev/) client for Redis. +The sections below explain how to install `go-redis` and connect your application to a Redis database. -## go-redis +`go-redis` requires a running Redis or +[Redis Stack]({{< relref "/operate/oss_and_stack/install/install-stack/" >}}) server. +See [Getting started]({{< relref "/operate/oss_and_stack/install/" >}}) for Redis installation +instructions. -[go-redis](https://github.com/redis/go-redis) provides Go clients for various flavors of Redis and a type-safe API for each Redis command. +## Install -### Install - -`go-redis` supports last two Go versions and only works with Go modules. -So, first, you need to initialize a Go module: +`go-redis` supports the last two Go versions. You can only use it from within +a Go module, so you must initialize a Go module before you start, or add your code to +an existing module: ``` go mod init github.com/my/repo ``` -To install go-redis/v9: +Use the `go get` command to install `go-redis/v9`: ``` go get github.com/redis/go-redis/v9 ``` -### Connect +## Connect -To connect to a Redis server: +The following example shows the simplest way to connect to a Redis server: ```go import ( @@ -47,16 +50,17 @@ import ( "github.com/redis/go-redis/v9" ) -func main() { +func main() { client := redis.NewClient(&redis.Options{ Addr: "localhost:6379", - Password: "", // no password set - DB: 0, // use default DB + Password: "", // No password set + DB: 0, // Use default DB + Protocol: 2, // Connection protocol }) } ``` -Another way to connect is using a connection string. +You can also connect using a connection string: ```go opt, err := redis.ParseURL("redis://:@localhost:6379/") @@ -67,7 +71,8 @@ if err != nil { client := redis.NewClient(opt) ``` -Store and retrieve a simple string. +After connecting, you can test the connection by storing and retrieving +a simple [string]({{< relref "/develop/data-types/strings" >}}): ```go ctx := context.Background() @@ -84,24 +89,78 @@ if err != nil { fmt.Println("foo", val) ``` -Store and retrieve a map. +You can also easily store and retrieve a [hash]({{< relref "/develop/data-types/hashes" >}}): ```go -session := map[string]string{"name": "John", "surname": "Smith", "company": "Redis", "age": "29"} -for k, v := range session { - err := client.HSet(ctx, "user-session:123", k, v).Err() - if err != nil { - panic(err) - } +hashFields := []string{ + "model", "Deimos", + "brand", "Ergonom", + "type", "Enduro bikes", + "price", "4972", +} + +res1, err := rdb.HSet(ctx, "bike:1", hashFields).Result() + +if err != nil { + panic(err) +} + +fmt.Println(res1) // >>> 4 + +res2, err := rdb.HGet(ctx, "bike:1", "model").Result() + +if err != nil { + panic(err) +} + +fmt.Println(res2) // >>> Deimos + +res3, err := rdb.HGet(ctx, "bike:1", "price").Result() + +if err != nil { + panic(err) +} + +fmt.Println(res3) // >>> 4972 + +res4, err := rdb.HGetAll(ctx, "bike:1").Result() + +if err != nil { + panic(err) +} + +fmt.Println(res4) +// >>> map[brand:Ergonom model:Deimos price:4972 type:Enduro bikes] + ``` + + Use + [struct tags](https://stackoverflow.com/questions/10858787/what-are-the-uses-for-struct-tags-in-go) + of the form `redis:""` with the `Scan()` method to parse fields from + a hash directly into corresponding struct fields: + + ```go +type BikeInfo struct { + Model string `redis:"model"` + Brand string `redis:"brand"` + Type string `redis:"type"` + Price int `redis:"price"` +} + +var res4a BikeInfo +err = rdb.HGetAll(ctx, "bike:1").Scan(&res4a) + +if err != nil { + panic(err) } -userSession := client.HGetAll(ctx, "user-session:123").Val() -fmt.Println(userSession) +fmt.Printf("Model: %v, Brand: %v, Type: %v, Price: $%v\n", + res4a.Model, res4a.Brand, res4a.Type, res4a.Price) +// >>> Model: Deimos, Brand: Ergonom, Type: Enduro bikes, Price: $4972 ``` -#### Connect to a Redis cluster +### Connect to a Redis cluster -To connect to a Redis cluster, use `NewClusterClient`. +To connect to a Redis cluster, use `NewClusterClient()`. ```go client := redis.NewClusterClient(&redis.ClusterOptions{ @@ -113,11 +172,12 @@ client := redis.NewClusterClient(&redis.ClusterOptions{ }) ``` -#### Connect to your production Redis with TLS +### Connect to your production Redis with TLS -When you deploy your application, use TLS and follow the [Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines. +When you deploy your application, use TLS and follow the +[Redis security]({{< relref "/operate/oss_and_stack/management/security/" >}}) guidelines. -Establish a secure connection with your Redis database using this snippet. +Establish a secure connection with your Redis database: ```go // Load client cert @@ -159,23 +219,283 @@ if err != nil { fmt.Println("foo", val) ``` +## Example: Index and search JSON documents -#### dial tcp: i/o timeout +Start by connecting to the Redis server: -You get a `dial tcp: i/o timeout` error when `go-redis` can't connect to the Redis Server, for example, when the server is down or the port is protected by a firewall. To check if Redis Server is listening on the port, run telnet command on the host where the `go-redis` client is running. +```go +import ( + "context" + "fmt" + + "github.com/redis/go-redis/v9" +) + +func main() { + ctx := context.Background() + + rdb := redis.NewClient(&redis.Options{ + Addr: "localhost:6379", + Password: "", + DB: 0, + Protocol: 2, + }) + + // ... +} +``` + +Add some `map` objects to store in JSON format in the database: ```go -telnet localhost 6379 -Trying 127.0.0.1... -telnet: Unable to connect to remote host: Connection refused +user1 := map[string]interface{}{ + "name": "Paul John", + "email": "paul.john@example.com", + "age": 42, + "city": "London", +} + +user2 := map[string]interface{}{ + "name": "Eden Zamir", + "email": "eden.zamir@example.com", + "age": 29, + "city": "Tel Aviv", +} + +user3 := map[string]interface{}{ + "name": "Paul Zamir", + "email": "paul.zamir@example.com", + "age": 35, + "city": "Tel Aviv", +} ``` -If you use Docker, Istio, or any other service mesh/sidecar, make sure the app starts after the container is fully available, for example, by configuring healthchecks with Docker and holdApplicationUntilProxyStarts with Istio. -For more information, see [Healthcheck](https://docs.docker.com/engine/reference/run/#healthcheck). +Use the code below to create a search index. The `FTCreateOptions` parameter enables +indexing only for JSON objects where the key has a `user:` prefix. +The +[schema]({{< relref "/develop/interact/search-and-query/indexing" >}}) +for the index has three fields for the user's name, age, and city. +The `FieldName` field of the `FieldSchema` struct specifies a +[JSON path]({{< relref "/develop/data-types/json/path" >}}) +that identifies which data field to index. Use the `As` struct field +to provide an alias for the JSON path expression. You can use +the alias in queries as a short and intuitive way to refer to the +expression, instead of typing it in full: -### Observability +```go +_, err := rdb.FTCreate( + ctx, + "idx:users", + // Options: + &redis.FTCreateOptions{ + OnJSON: true, + Prefix: []interface{}{"user:"}, + }, + // Index schema fields: + &redis.FieldSchema{ + FieldName: "$.name", + As: "name", + FieldType: redis.SearchFieldTypeText, + }, + &redis.FieldSchema{ + FieldName: "$.city", + As: "city", + FieldType: redis.SearchFieldTypeTag, + }, + &redis.FieldSchema{ + FieldName: "$.age", + As: "age", + FieldType: redis.SearchFieldTypeNumeric, + }, +).Result() -To monitor go-redis performance and trace the execution of Redis commands, you can install OpenTelemetry instrumentation: +if err != nil { + panic(err) +} +``` + +Add the three sets of user data to the database as +[JSON]({{< relref "/develop/data-types/json" >}}) objects. +If you use keys with the `user:` prefix then Redis will index the +objects automatically as you add them: + +```go +_, err = rdb.JSONSet(ctx, "user:1", "$", user1).Result() + +if err != nil { + panic(err) +} + +_, err = rdb.JSONSet(ctx, "user:2", "$", user2).Result() + +if err != nil { + panic(err) +} + +_, err = rdb.JSONSet(ctx, "user:3", "$", user3).Result() + +if err != nil { + panic(err) +} +``` + +You can now use the index to search the JSON objects. The +[query]({{< relref "/develop/interact/search-and-query/query" >}}) +below searches for objects that have the text "Paul" in any field +and have an `age` value in the range 30 to 40: + +```go +searchResult, err := rdb.FTSearch( + ctx, + "idx:users", + "Paul @age:[30 40]", +).Result() + +if err != nil { + panic(err) +} + +fmt.Println(searchResult) +// >>> {1 [{user:3 map[$:{"age":35,"city":"Tel Aviv"... +``` + +## Example: Index and search hash documents + +Start by connecting to the Redis server as before: + +```go +import ( + "context" + "fmt" + + "github.com/redis/go-redis/v9" +) + +func main() { + ctx := context.Background() + + rdb := redis.NewClient(&redis.Options{ + Addr: "localhost:6379", + Password: "", + DB: 0, + Protocol: 2, + }) + + // ... +} +``` + +In this example, the user objects will be stored as hashes in the database. Use a `string` +array in the form of name-value pairs to supply the data for the +hash fields: + +```go +user1 := []string{ + "name", "Paul John", + "email", "paul.john@example.com", + "age", "42", + "city", "London", +} + +user2 := []string{ + "name", "Eden Zamir", + "email", "eden.zamir@example.com", + "age", "29", + "city", "Tel Aviv", +} + +user3 := []string{ + "name", "Paul Zamir", + "email", "paul.zamir@example.com", + "age", "35", + "city", "Tel Aviv", +} +``` + +It is easier to create the index for hash objects than +for JSON objects. Use the `FTCreateOptions` parameter to enable +indexing only for hash objects, but specify the same `user:` prefix +as before. You don't need the `As:` field in the schema parameters +here because hash fields have simple identifiers. They have no +JSON path expression and don't require an alias: + +```go +_, err := rdb.FTCreate( + ctx, + "idx:users", + // Options: + &redis.FTCreateOptions{ + OnHash: true, + Prefix: []interface{}{"user:"}, + }, + // Index schema fields: + &redis.FieldSchema{ + FieldName: "name", + FieldType: redis.SearchFieldTypeText, + }, + &redis.FieldSchema{ + FieldName: "city", + FieldType: redis.SearchFieldTypeTag, + }, + &redis.FieldSchema{ + FieldName: "age", + FieldType: redis.SearchFieldTypeNumeric, + }, +).Result() + +if err != nil { + panic(err) +} +``` + +Add the user data arrays to the database as hash objects. Redis will +index the hashes automatically because their keys have the +`user:` prefix: + +```go +_, err = rdb.HSet(ctx, "user:1", user1).Result() + +if err != nil { + panic(err) +} + +_, err = rdb.HSet(ctx, "user:2", user2).Result() + +if err != nil { + panic(err) +} + +_, err = rdb.HSet(ctx, "user:2", user3).Result() + +if err != nil { + panic(err) +} +``` + +The hashes have a structure very much like the JSON objects +from the previous example, so you can search the database with the +same query as before: + +```go +searchResult, err := rdb.FTSearch( + ctx, + "idx:users", + "Paul @age:[30 40]", +).Result() + +if err != nil { + panic(err) +} + +fmt.Println(searchResult) +// >>> {1 [{user:2 map[age:35 city:Tel Aviv... +``` + +## Observability + +`go-redis` supports [OpenTelemetry](https://opentelemetry.io/) instrumentation. +to monitor performance and trace the execution of Redis commands. +For example, the following code instruments Redis commands to collect traces, logs, and metrics: ```go import ( @@ -196,11 +516,8 @@ if err := redisotel.InstrumentMetrics(rdb); err != nil { } ``` -The code above instruments Redis commands to collect traces, logs, and metrics. You can find the full example on [GitHub](https://github.com/redis/go-redis/blob/master/example/otel/README.md). - -OpenTelemetry is a vendor-agnostic observability framework that allows you to export data to Prometheus, Jaeger, Uptrace, and more. OpenTelemetry supports [distributed tracing](https://uptrace.dev/opentelemetry/distributed-tracing.html), metrics, and logs. - -You can also use OpenTelemetry for [monitoring Redis Server](https://uptrace.dev/blog/redis-monitoring.html) performance metrics, which works by periodically executing the Redis `INFO` command and turning results into [OpenTelemetry metrics](https://uptrace.dev/opentelemetry/metrics.html). +See the `go-redis` [GitHub repo](https://github.com/redis/go-redis/blob/master/example/otel/README.md). +for more OpenTelemetry examples. ### Learn more diff --git a/content/develop/connect/insight/_index.md b/content/develop/connect/insight/_index.md index 12ee89fb53..e394a55261 100644 --- a/content/develop/connect/insight/_index.md +++ b/content/develop/connect/insight/_index.md @@ -159,6 +159,11 @@ These are the locations on supported platforms: You can install Redis Insight on operating systems that are not officially supported, but it may not behave as expected. {{< /note >}} +## Redis Insight API (only for Docker) + +If you are running Redis Insight from [Docker]({{< relref "/operate/redisinsight/install/install-on-docker" >}}), +you can access the API from `http://localhost:5540/api/docs`. + ## Feedback To provide your feedback, [open a ticket in our Redis Insight repository](https://github.com/Redis-Insight/Redis-Insight/issues/new). diff --git a/content/develop/data-types/bitfields.md b/content/develop/data-types/bitfields.md index 78718228a3..16482b3229 100644 --- a/content/develop/data-types/bitfields.md +++ b/content/develop/data-types/bitfields.md @@ -31,7 +31,7 @@ Bitfields support atomic read, write and increment operations, making them a goo ## Example -Suppose you want to maintain two metrics for various bicycles: the current price and the number of owners over time. You can represent these counters with a 32-bit wide bitfield per for each bike. +Suppose you want to maintain two metrics for various bicycles: the current price and the number of owners over time. You can represent these counters with a 32-bit wide bitfield for each bike. * Bike 1 initially costs 1,000 (counter in offset 0) and has never had an owner. After being sold, it's now considered used and the price instantly drops to reflect its new condition, and it now has an owner (offset 1). After quite some time, the bike becomes a classic. The original owner sells it for a profit, so the price goes up and the number of owners does as well.Finally, you can look at the bike's current price and number of owners. diff --git a/content/develop/get-started/vector-database.md b/content/develop/get-started/vector-database.md index 123b7e8760..cfd739a57c 100644 --- a/content/develop/get-started/vector-database.md +++ b/content/develop/get-started/vector-database.md @@ -76,7 +76,7 @@ Connect to Redis. By default, Redis returns binary responses. To decode them, yo {{< clients-example search_vss connect />}}
{{% alert title="Tip" color="warning" %}} -Instead of using a local Redis Stack server, you can copy and paste the connection details from the Redis Cloud database configuration page. Here is an example connection string of a Cloud database that is hosted in the AWS region `us-east-1` and listens on port 16379: `redis-16379.c283.us-east-1-4.ec2.cloud.redislabs.com:16379`. The connection string has the format `host:port`. You must also copy and paste the username and password of your Cloud database. The line of code for connecting with the default user changes then to `client = redis.Redis(host="redis-16379.c283.us-east-1-4.ec2.cloud.redislabs.com", port=16379, password="your_password_here" decode_responses=True)`. +Instead of using a local Redis Stack server, you can copy and paste the connection details from the Redis Cloud database configuration page. Here is an example connection string of a Cloud database that is hosted in the AWS region `us-east-1` and listens on port 16379: `redis-16379.c283.us-east-1-4.ec2.cloud.redislabs.com:16379`. The connection string has the format `host:port`. You must also copy and paste the username and password of your Cloud database. The line of code for connecting with the default user changes then to `client = redis.Redis(host="redis-16379.c283.us-east-1-4.ec2.cloud.redislabs.com", port=16379, password="your_password_here", decode_responses=True)`. {{% /alert %}} @@ -115,7 +115,7 @@ Now iterate over the `bikes` array to store the data as [JSON]({{< relref "/dev {{< clients-example search_vss load_data />}} -Once loaded, you can retrieve a specific attributes from one of the JSON documents in Redis using a [JSONPath](https://goessner.net/articles/JsonPath/) expression: +Once loaded, you can retrieve a specific attribute from one of the JSON documents in Redis using a [JSONPath](https://goessner.net/articles/JsonPath/) expression: {{< clients-example search_vss get />}} diff --git a/content/develop/interact/search-and-query/advanced-concepts/vectors.md b/content/develop/interact/search-and-query/advanced-concepts/vectors.md index 3e6c3bc301..8074a833c2 100644 --- a/content/develop/interact/search-and-query/advanced-concepts/vectors.md +++ b/content/develop/interact/search-and-query/advanced-concepts/vectors.md @@ -441,7 +441,7 @@ FT.SEARCH movies "(@category:{action} ~@category:{drama})=>[KNN 10 @doc_embeddin Among the movies that have `drama` or `action` as a category tag, return the top 10 nearest neighbors and explicitly set the filter mode (hybrid policy) to "ad-hoc brute force" rather than it being auto-selected: ``` -FT.SEARCH movies "(@category:{drama | action})=>[KNN 10 @doc_embedding $BLOB HYBRID_POLICY ADHOC_BF]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" SORTBY __vec_scores DIALECT 4 +FT.SEARCH movies "(@category:{drama | action})=>[KNN 10 @doc_embedding $BLOB HYBRID_POLICY ADHOC_BF]" PARAMS 2 BLOB "\x12\xa9\xf5\x6c" SORTBY __vec_score DIALECT 4 ``` Among the movies that have `action` as a category tag, return the top 10 nearest neighbors and explicitly set the filter mode (hybrid policy) to "batches" and batch size 50 using a query parameter: diff --git a/content/develop/interact/search-and-query/query/combined.md b/content/develop/interact/search-and-query/query/combined.md index e49c2b4a33..0a043b0253 100644 --- a/content/develop/interact/search-and-query/query/combined.md +++ b/content/develop/interact/search-and-query/query/combined.md @@ -54,15 +54,15 @@ FT.SEARCH index "@text_field:( value1 value2 ... )" The following example shows you a query that finds bicycles in new condition and in a price range from 500 USD to 1000 USD: -``` +{{< clients-example query_combined combined1 >}} FT.SEARCH idx:bicycle "@price:[500 1000] @condition:{new}" -``` +{{< /clients-example >}} You might also be interested in bicycles for kids. The query below shows you how to combine a full-text search with the criteria from the previous query: -``` +{{< clients-example query_combined combined2 >}} FT.SEARCH idx:bicycle "kids (@price:[500 1000] @condition:{used})" -``` +{{< /clients-example >}} ## OR @@ -89,21 +89,21 @@ FT.SEARCH index "@tag_field:{ value1 | value2 | ... }" The following query shows you how to find used bicycles that contain either the word 'kids' or 'small': -``` +{{< clients-example query_combined combined3 >}} FT.SEARCH idx:bicycle "(kids | small) @condition:{used}" -``` +{{< /clients-example >}} The previous query searches across all text fields. The following example shows you how to limit the search to the description field: -``` +{{< clients-example query_combined combined4 >}} FT.SEARCH idx:bicycle "@description:(kids | small) @condition:{used}" -``` +{{< /clients-example >}} If you want to extend the search to new bicycles, then the below example shows you how to do that: -``` +{{< clients-example query_combined combined5 >}} FT.SEARCH idx:bicycle "@description:(kids | small) @condition:{new | used}" -``` +{{< /clients-example >}} ## NOT @@ -115,9 +115,9 @@ FT.SEARCH index "-(expr)" If you want to exclude new bicycles from the search within the previous price range, you can use this query: -``` +{{< clients-example query_combined combined6 >}} FT.SEARCH idx:bicycle "@price:[500 1000] -@condition:{new}" -``` +{{< /clients-example >}} ## Numeric filter @@ -140,8 +140,8 @@ FT.SEARCH index "(filter_expr)=>[KNN num_neighbours @field $vector]" PARAMS 2 ve Here is an example: -``` +{{< clients-example query_combined combined7 >}} FT.SEARCH idx:bikes_vss "(@price:[500 1000] @condition:{new})=>[KNN 3 @vector $query_vector]" PARAMS 2 "query_vector" "Z\xf8\x15:\xf23\xa1\xbfZ\x1dI>\r\xca9..." DIALECT 2 -``` +{{< /clients-example >}} The [vector search article]({{< relref "/develop/interact/search-and-query/query/vector-search" >}}) provides further details about vector queries in general. diff --git a/content/embeds/k8s-admission-webhook-cert.md b/content/embeds/k8s-admission-webhook-cert.md index 5b432cee4b..1d1fd141af 100644 --- a/content/embeds/k8s-admission-webhook-cert.md +++ b/content/embeds/k8s-admission-webhook-cert.md @@ -33,7 +33,6 @@ - name: redisenterprise.admission.redislabs clientConfig: caBundle: $CERT - admissionReviewVersions: ["v1beta1"] EOF ``` diff --git a/content/glossary/_index.md b/content/glossary/_index.md index 6e43c69ac8..c82c8ab6bd 100644 --- a/content/glossary/_index.md +++ b/content/glossary/_index.md @@ -149,7 +149,7 @@ More info: [FQDN wikipedia](https://en.wikipedia.org/wiki/Fully_qualified_domain {{%definition "`fysnc`"%}} Linux command to synchronize a file's in-core state with a storage device -More info: [`fsync` man page]("https://man7.org/linux/man-pages/man2/fsync.2.html") +More info: [`fsync` man page](https://man7.org/linux/man-pages/man2/fsync.2.html) {{%/definition%}} ## G - J {#letter-g} diff --git a/content/integrate/amazon-bedrock/set-up-redis.md b/content/integrate/amazon-bedrock/set-up-redis.md index a7bf537bbc..dc10015030 100644 --- a/content/integrate/amazon-bedrock/set-up-redis.md +++ b/content/integrate/amazon-bedrock/set-up-redis.md @@ -75,9 +75,9 @@ To set up a Redis Cloud instance for Bedrock, you need to: {{The General settings of the Setup tab.}} -1. In the **Version** section, select **Redis 7.2**. +1. In the **Version** section, select **Redis 7.2** or **Redis 7.4**. - {{Version selection between Redis 6.2 and 7.2}} + {{Version selection between Redis 6.2, 7.2, and 7.4}} 1. In the **Advanced options** section, select Multi-AZ to ensure [high-availability]({{< relref "/operate/rc/databases/configuration/high-availability" >}}). diff --git a/content/integrate/write-behind/data-transformation/data-transformation-pipeline.md b/content/integrate/write-behind/data-transformation/data-transformation-pipeline.md index 28b5d8e8f7..50e4e6543b 100644 --- a/content/integrate/write-behind/data-transformation/data-transformation-pipeline.md +++ b/content/integrate/write-behind/data-transformation/data-transformation-pipeline.md @@ -32,7 +32,7 @@ For example, the default job can streamline tasks such as adding a prefix or pos Currently, the default job is supported for ingest pipelines only. ### Example -This example demonstrates the process of adding an `app_code` field with a value of `foo` using the [add_field](/content/rdi/reference/data-transformation-block-types/add_field.md) block to all tables that lack explicitly defined jobs. Additionally, it appends an `aws` prefix and a `gcp` postfix to every generated hash key. +This example demonstrates the process of adding an `app_code` field with a value of `foo` using the [add_field]({{}}) block to all tables that lack explicitly defined jobs. Additionally, it appends an `aws` prefix and a `gcp` postfix to every generated hash key. default.yaml ```yaml diff --git a/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-3.md b/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-3.md index 7b28084dc2..3230516388 100644 --- a/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-3.md +++ b/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-3.md @@ -168,3 +168,7 @@ On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redi * `autoUpgrade` set to true by operator might cause unexpected bdb upgrades when `redisUpgradePolicy` is set to true (RED-72351) Contact support if your deployment is impacted. + +## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 6.2.18-58 release notes]({{}}). diff --git a/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41-jan-2023.md b/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41-jan-2023.md index 8d7175f532..8814a1f98a 100644 --- a/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41-jan-2023.md +++ b/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41-jan-2023.md @@ -57,3 +57,7 @@ Be aware the following changes included in this release affect the upgrade proce ## Known limitations See [Redis Enterprise for Kubernetes release notes 6.2.18-41 (Dec 2022)]({{< relref "/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41.md" >}}). + +## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 6.2.18-72 release notes]({{}}). diff --git a/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41.md b/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41.md index 799f35f49d..a7458eef36 100644 --- a/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41.md +++ b/content/operate/kubernetes/release-notes/6-2-18-releases/k8s-6-2-18-41.md @@ -138,3 +138,7 @@ On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redi * `autoUpgrade` set to true by operator might cause unexpected bdb upgrades when `redisUpgradePolicy` is set to true (RED-72351) Contact support if your deployment is impacted. + +## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 6.2.18-65 release notes]({{}}). diff --git a/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-5.md b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-5.md index 123fc0cb7e..63f68f4209 100644 --- a/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-5.md +++ b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-5.md @@ -59,3 +59,8 @@ Be aware the following changes included in this release affect the upgrade proce ## Known limitations See [Redis Enterprise for Kubernetes release notes 6.4.2-4 (March 2023)]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/k8s-6-4-2-4.md" >}}). + +## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-61 release notes]({{}}). + diff --git a/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-6.md b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-6.md index 2536b30497..c8eb1b07a8 100644 --- a/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-6.md +++ b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-6.md @@ -177,3 +177,7 @@ Be aware the following changes included in this release affect the upgrade proce * **Long cluster names cause routes to be rejected (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer. * **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence. + +## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-81 release notes]({{}}). \ No newline at end of file diff --git a/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8-dec23.md b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8-dec23.md index e581b5d790..1277a1b911 100644 --- a/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8-dec23.md +++ b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8-dec23.md @@ -59,4 +59,8 @@ See [6.4.2-8 (July 2023) release notes]({{< relref "/operate/kubernetes/release- ## Known limitations -See [6.4.2-8 (July 2023) release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8#known-limitations" >}}). \ No newline at end of file +See [6.4.2-8 (July 2023) release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8#known-limitations" >}}). + +## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-103 release notes]({{}}). \ No newline at end of file diff --git a/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8-oct24.md b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8-oct24.md new file mode 100644 index 0000000000..d6a4f251c2 --- /dev/null +++ b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8-oct24.md @@ -0,0 +1,62 @@ +--- +alwaysopen: false +categories: +- docs +- operate +- kubernetes +description: The Redis Enterprise K8s 6.4.2-8 release supports Redis Enterprise Software 6.4.2. +linkTitle: 6.4.2-8 (Oct 2024) +title: Redis Enterprise for Kubernetes release notes 6.4.2-8 (Oct 2024) +weight: 53 +--- + +## Overview + +This is a maintenance release of Redis Enterprise for Kubernetes version 6.4.2-8 and includes an updated Redis Enterprise image. + +## New in this release + +### Feature enhancements + +* New Redis Enterprise software version 6.4.2-115 + +## Upgrade considerations + +Be aware the following changes included in this release affect the upgrade process. Please read carefully before upgrading to 6.4.2-8. + +* **Upgrade path to versions 7.2.4-2 or later** + + Upgrading from this versions 7.2.4-2 or 7.2.4-7 is not possible using the OpenShift Operator Lifecycle Manager (OLM). OLM users will need to skip to version 7.2.4-10 to upgrade from this release version. + +* **ValidatingWebhookConfiguration** + + This release uses a new `ValidatingWebhookConfiguration` resource to replace the `redb-admission` webhook resource. To use releases 6.4.2-4 or later, delete the old webhook resource and apply the new file. See [upgrade Redis cluster]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#reapply-webhook" >}}) for instructions. + +* **OpenShift SCC** + + This release includes a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for more info. + +## Compatibility + +See [6.4.2-8 (July 2023) release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8#compatibility" >}}). + +### Images + +* **Redis Enterprise**: `redislabs/redis:6.4.2-115` +* **Operator**: `redislabs/operator:6.4.2-8` +* **Services Rigger**: `redislabs/k8s-controller:6.4.2-8.` + +#### OpenShift images + +* **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:6.4.2-115.rhel8-openshift` + (or `redislabs/redis-enterprise:6.4.2-115.rhel7-openshift` if upgrading from RHEL 7) +* **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:6.4.2-8` +* **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:6.4.2-8` + +#### OLM bundle + +* **Redis Enterprise operator bundle** : `v6.4.2-8.10` + +## Known limitations + +See [6.4.2-8 (July 2023) release notes]({{< relref "/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8#known-limitations" >}}). \ No newline at end of file diff --git a/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8.md b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8.md index 04c84801fa..b53d9a2aaf 100644 --- a/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8.md +++ b/content/operate/kubernetes/release-notes/6-4-2-releases/6-4-2-8.md @@ -119,4 +119,8 @@ The following table shows supported distributions at the time of this release. Y * **Long cluster names cause routes to be rejected (RED-25871)** A cluster name longer than 20 characters will result in a rejected route configuration because the host part of the domain name exceeds 63 characters. The workaround is to limit the cluster name to 20 characters or fewer. -* **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence. \ No newline at end of file +* **Cluster CR (REC) errors are not reported after invalid updates (RED-25542)** A cluster CR specification error is not reported if two or more invalid CR resources are updated in sequence. + +## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-94 release notes]({{}}). \ No newline at end of file diff --git a/content/operate/kubernetes/release-notes/6-4-2-releases/_index.md b/content/operate/kubernetes/release-notes/6-4-2-releases/_index.md index ad98798bb4..90b4daafab 100644 --- a/content/operate/kubernetes/release-notes/6-4-2-releases/_index.md +++ b/content/operate/kubernetes/release-notes/6-4-2-releases/_index.md @@ -32,5 +32,8 @@ Operator version 6.4.2-6 includes a fix for this issue. On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redis cluster unresponsive in some cases. A fix is available in the 6.4.2-5 release. Upgrade your operator version to 6.4.2-5 or later before upgrading your Kubernetes cluster. +## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2 release notes]({{}}). {{}} \ No newline at end of file diff --git a/content/operate/kubernetes/release-notes/6-4-2-releases/k8s-6-4-2-4.md b/content/operate/kubernetes/release-notes/6-4-2-releases/k8s-6-4-2-4.md index 83cde4066c..acc4e6dedf 100644 --- a/content/operate/kubernetes/release-notes/6-4-2-releases/k8s-6-4-2-4.md +++ b/content/operate/kubernetes/release-notes/6-4-2-releases/k8s-6-4-2-4.md @@ -189,4 +189,8 @@ On clusters with more than 9 REC nodes, a Kubernetes upgrade can render the Redi The workaround is to use the newer (current) revision of the [quick start]({{< relref "/operate/kubernetes/deployment/quick-start.md" >}}). * `autoUpgrade` set to `true` can cause unexpected bdb upgrades when `redisUpgradePolicy` is set to `true` (RED-72351) - Contact support if your deployment is impacted. \ No newline at end of file + Contact support if your deployment is impacted. + + ## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 6.4.2-43 release notes]({{}}). \ No newline at end of file diff --git a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-03-24.md b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-03-24.md index d21da88262..6a79115a12 100644 --- a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-03-24.md +++ b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-03-24.md @@ -22,6 +22,8 @@ This is a maintenance release to support Redis Enterprise Software version 7.2.4 ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-105 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-12. diff --git a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-08-2024.md b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-08-2024.md index 0a09f771db..b7a398d4e5 100644 --- a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-08-2024.md +++ b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12-08-2024.md @@ -22,6 +22,8 @@ This is a maintenance release to support Redis Enterprise Software version 7.2.4 ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-109 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-12. @@ -42,6 +44,7 @@ Versions 6.4.2-4 and later include a new `ValidatingWebhookConfiguration` resour Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that you need to bind to your service account before upgrading. OpenShift clusters running version 6.2.12 or earlier upgrading to version 6.2.18 or later might get stuck if you skip this step. See [upgrade a Redis Enterprise cluster (REC)]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#before-upgrading" >}}) for instructions. + ### Upcoming changes - A future release of Redis Enterprise will remove support for RHEL7. We recommend migrating to RHEL8. diff --git a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12.md b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12.md index 0d12d80710..5c1f4c32e3 100644 --- a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12.md +++ b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-12.md @@ -34,6 +34,8 @@ This is a maintenance release with a few enhancements/fixes on the Kubernetes pr ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-92 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-12. diff --git a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-2.md b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-2.md index 025d0698f7..cdccbaa950 100644 --- a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-2.md +++ b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-2.md @@ -49,6 +49,8 @@ The following fields were added to the RedisEnterpriseCluster (REC) custom resou ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-52 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-2. diff --git a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-7.md b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-7.md index 44443c8976..4baa1b959d 100644 --- a/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-7.md +++ b/content/operate/kubernetes/release-notes/7-2-4-releases/7-2-4-7.md @@ -35,6 +35,8 @@ The following are the notable changes: ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-64 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-7. diff --git a/content/operate/kubernetes/release-notes/7-2-4-releases/_index.md b/content/operate/kubernetes/release-notes/7-2-4-releases/_index.md index 9acf0d2f56..0da8335259 100644 --- a/content/operate/kubernetes/release-notes/7-2-4-releases/_index.md +++ b/content/operate/kubernetes/release-notes/7-2-4-releases/_index.md @@ -31,6 +31,8 @@ The following are the notable changes: ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading to 7.2.4-2. diff --git a/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-03-24.md b/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-03-24.md index 631abb6b4e..b52ba57246 100644 --- a/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-03-24.md +++ b/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-03-24.md @@ -16,6 +16,8 @@ The primary purpose of this release is to support [Redis Enterprise 7.4.2]({{< r ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.4.2-104 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading. diff --git a/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-12.md b/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-12.md index 235e6c9c6c..9e6aac64f8 100644 --- a/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-12.md +++ b/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-12.md @@ -42,6 +42,8 @@ This release has many enhancements, most notably support for persistent volume e ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.4.2-129 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading. @@ -85,7 +87,6 @@ Any distribution not listed below is not supported for production workloads. | **VMware TKGI version** | **1.15** | **1.16** | **1.17** | **1.18** | | | | | ❌ | ✅ | ✅ | ✅ | | | - ## Downloads - **Redis Enterprise**: `redislabs/redis:7.4.2-129` diff --git a/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-2.md b/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-2.md index e30b2ed7d2..bda699d19a 100644 --- a/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-2.md +++ b/content/operate/kubernetes/release-notes/7-4-2-releases/7-4-2-2.md @@ -42,6 +42,8 @@ The primary purpose of this release is to support [Redis Enterprise 7.4.2]({{< r ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.4.2-54 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading. diff --git a/content/operate/kubernetes/release-notes/7-4-2-releases/_index.md b/content/operate/kubernetes/release-notes/7-4-2-releases/_index.md index 15a913ed7c..1a07b12963 100644 --- a/content/operate/kubernetes/release-notes/7-4-2-releases/_index.md +++ b/content/operate/kubernetes/release-notes/7-4-2-releases/_index.md @@ -17,6 +17,8 @@ weight: 54 ## Version changes +For a list of fixes related to CVEs, see the [Redis Enterprise 7.4.6-22 release notes]({{}}). + ### Breaking changes The following changes included in this release affect the upgrade process. Please read carefully before upgrading. diff --git a/content/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2-oct24.md b/content/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2-oct24.md index e9b5832cc3..96c21e498c 100644 --- a/content/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2-oct24.md +++ b/content/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2-oct24.md @@ -12,7 +12,8 @@ weight: 3 ## Highlights -This is a maintenance release to support [Redis Enterprise Software version 7.4.6-77]({{}}). For version changes, supported distributions, and known limitations, see the [release notes for 7-4-6-2 (July 2024)]({{}}). +This is a maintenance release to support [Redis Enterprise Software version 7.4.6-77]({{}}). For version changes, supported distributions, and known limitations, see the [release notes for 7-4-6-2 (July 2024)]({{}}). + ## Downloads diff --git a/content/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2-october24.md b/content/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2-october24.md new file mode 100644 index 0000000000..3ddbbc957f --- /dev/null +++ b/content/operate/kubernetes/release-notes/7-4-6-releases/7-4-6-2-october24.md @@ -0,0 +1,31 @@ +--- +alwaysopen: false +categories: +- docs +- operate +- kubernetes +description: This is a maintenance release with a new version of Redis Enterprise Software 7.4.6. +linkTitle: 7.4.6-2 (October 2024) +title: Redis Enterprise for Kubernetes 7.4.6-2 (October 2024) release notes +weight: 2 +--- + +## Highlights + +This is a maintenance release to support [Redis Enterprise Software version 7.4.6-102]({{}}). For version changes, supported distributions, and known limitations, see the [release notes for 7-4-6-2 (July 2024)]({{}}). + +## Downloads + +- **Redis Enterprise**: `redislabs/redis:7.4.102` +- **Operator**: `redislabs/operator:7.4.6-2` +- **Services Rigger**: `redislabs/k8s-controller:7.4.6-2` + +### OpenShift images + +- **Redis Enterprise**: `registry.connect.redhat.com/redislabs/redis-enterprise:7.4.102.rhel8-openshift` +- **Operator**: `registry.connect.redhat.com/redislabs/redis-enterprise-operator:7.4.6-2` +- **Services Rigger**: `registry.connect.redhat.com/redislabs/services-manager:7.4.6-2` + +### OLM bundle + +**Redis Enterprise operator bundle** : `v7.4.6-2.3` diff --git a/content/operate/kubernetes/release-notes/7-4-6-releases/_index.md b/content/operate/kubernetes/release-notes/7-4-6-releases/_index.md index e1b54bdc74..0589351703 100644 --- a/content/operate/kubernetes/release-notes/7-4-6-releases/_index.md +++ b/content/operate/kubernetes/release-notes/7-4-6-releases/_index.md @@ -31,6 +31,10 @@ Versions 6.4.2-6 and later include a new SCC (`redis-enterprise-scc-v2`) that yo - Future Redis Enterprise images will be UBI9-based only, without support for Ubuntu-based images. +## Security + +For a list of fixes related to CVEs, see the [Redis Enterprise 7.2.4-109 release notes]({{}}). + ## Supported distributions The following table shows supported distributions at the time of this release. You can also find this list in [Supported Kubernetes distributions]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}). diff --git a/content/operate/kubernetes/release-notes/previous-releases/k8s-5-4-10-8.md b/content/operate/kubernetes/release-notes/previous-releases/k8s-5-4-10-8.md index 9f1740304a..69d14c0404 100644 --- a/content/operate/kubernetes/release-notes/previous-releases/k8s-5-4-10-8.md +++ b/content/operate/kubernetes/release-notes/previous-releases/k8s-5-4-10-8.md @@ -35,7 +35,7 @@ See the top 4 articles in the new [Additonal Topics](https://github.com/RedisLab - Update app.redislabs.com API version to stable - We've updated the Redis Enterprise Cluster custom resource API from [alpha to stable](https://kubernetes.io/docs/concepts/overview/kubernetes-api/#api-versioning) to reflect the current state of maturity of our implementation. -[Both versions of the API are supported](https://kubernetes.io/docs/tasks/access-kubernetes-api/custom-resources/custom-resource-definition-versioning/) by Kubernetes versions that support specifying multiple API versions. +[Both versions of the API are supported](https://kubernetes.io/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definition-versioning/) by Kubernetes versions that support specifying multiple API versions. For legacy Kubernetes versions, deployment files are available in the documentation repository that utilize the alpha version of the API. diff --git a/content/operate/oss_and_stack/install/install-redis/install-redis-on-linux.md b/content/operate/oss_and_stack/install/install-redis/install-redis-on-linux.md index fa05b5029a..a3e0332b27 100644 --- a/content/operate/oss_and_stack/install/install-redis/install-redis-on-linux.md +++ b/content/operate/oss_and_stack/install/install-redis/install-redis-on-linux.md @@ -72,13 +72,13 @@ If your Linux distribution does not currently have Snap installed, you can insta You can start the Redis server as a background process using the `systemctl` command. This only applies to Ubuntu/Debian when installed using `apt`, and Red Hat/Rocky when installed using `yum`. {{< highlight bash >}} -sudo systemctl start redis +sudo systemctl start # redis or redis-server depending on platform {{< / highlight >}} To stop the server, use: {{< highlight bash >}} -sudo systemctl stop redis +sudo systemctl stop # redis or redis-server depending on platform {{< / highlight >}} ## Connect to Redis @@ -107,4 +107,4 @@ Once you have a running Redis instance, you may want to: * Connect using one of the [Redis clients]({{< relref "/develop/connect/clients" >}}) * [Install Redis "properly"]({{< relref "/operate/oss_and_stack/install/install-redis#install-redis-properly" >}}) for production use. - \ No newline at end of file + diff --git a/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgears/redisgears-1.2-release-notes.md b/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgears/redisgears-1.2-release-notes.md index bed43a2e1c..354234e4f7 100644 --- a/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgears/redisgears-1.2-release-notes.md +++ b/content/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgears/redisgears-1.2-release-notes.md @@ -16,11 +16,25 @@ weight: 99 ## Requirements -RedisGears v1.2.9 requires: +RedisGears v1.2.10 requires: - Minimum Redis compatibility version (database): 6.0.0 - Minimum Redis Enterprise Software version (cluster): 6.0.12 +## 1.2.10 (October 2024) + +This is a maintenance release for RedisGears 1.2 + +Update urgency: `LOW`: No need to upgrade unless there are new features or fixes. + +Details + +- Bug fixes: + - [#1114](https://github.com/redisgears/redisgears/pull/1114) (REPLICAOF and Redis Enterprise A-A only) Cross slot violation. Avoid using `RM_Call` + `SCAN` command which might replicate multiple keys deletion inside a `MULTI EXEC` block when a lazy expire takes place + +- Notes: + - RHEL7 is no longer supported + ## 1.2.9 (March 2024) This is a maintenance release for RedisGears 1.2 diff --git a/content/operate/rc/changelog/october-2024.md b/content/operate/rc/changelog/october-2024.md index bb363ad301..e8b5627724 100644 --- a/content/operate/rc/changelog/october-2024.md +++ b/content/operate/rc/changelog/october-2024.md @@ -7,11 +7,19 @@ categories: - rc description: New features, enhancements, and other changes added to Redis Cloud during October 2024. -highlights: Security fixes for CVE-2024-31449, CVE-2024-31227, CVE-2024-31228 +highlights: Redis 7.4 Preview on Redis Cloud Pro, Security fixes linktitle: October 2024 weight: 42 --- +## New Features + +### Redis 7.4 Preview on Redis Cloud Pro + +A preview of Redis 7.4 is now available on [Redis Cloud Pro databases]({{< relref "/operate/rc/databases/create-database/create-pro-database-new" >}}). + +Redis 7.4 offers hash field expiration and other feature set improvements. For more information on the changes in Redis 7.4, see the [Redis 7.4 release blog post](https://redis.io/blog/announcing-redis-community-edition-and-redis-stack-74). + ## Security fixes Redis Cloud has already been updated with patches for CVE-2024-31449, CVE-2024-31227, and CVE-2024-31228. No further action is required at this time. For more information, see the [Redis blog post](https://redis.io/blog/security-advisory-cve-2024-31449-cve-2024-31227-cve-2024-31228/) about these vulnerabilities. \ No newline at end of file diff --git a/content/operate/rc/databases/create-database/create-pro-database-new.md b/content/operate/rc/databases/create-database/create-pro-database-new.md index 6bf683514c..db06526a8d 100644 --- a/content/operate/rc/databases/create-database/create-pro-database-new.md +++ b/content/operate/rc/databases/create-database/create-pro-database-new.md @@ -107,9 +107,11 @@ The following settings are defined in the **General settings** of the **Setup** #### Version {#version} -{{Version selection between Redis 6.2 and 7.2}} +{{Version selection between Redis 6.2, 7.2, and 7.4.}} -The **Version** section lets you choose the Redis version of your databases. Choose **Redis 7.2** if you want to use the latest advanced features of Redis. +The **Version** section lets you choose the Redis version of your databases. Choose **Redis 7.2** if you want to use the latest stable version of Redis, or select **Redis 7.4** for the Redis 7.4 Preview. + +Redis 7.4 offers hash field expiration and other feature set improvements. For more information on the changes in Redis 7.4, see the [Redis 7.4 release notes](https://redis.io/blog/announcing-redis-community-edition-and-redis-stack-74). #### Advanced options {#advanced-options} diff --git a/content/operate/rc/security/database-security/_index.md b/content/operate/rc/security/database-security/_index.md index d6070d0144..1a20d93a6d 100644 --- a/content/operate/rc/security/database-security/_index.md +++ b/content/operate/rc/security/database-security/_index.md @@ -33,4 +33,4 @@ We strongly recommend enabling TLS for any application transmitting sensitive da ## Disk encryption -Redis Cloud provides encryption for all data stored on disk in Redis databases. See our [encrpytion at rest documentation]({{< relref "/operate/rc/security/encryption-at-rest.md" >}}) for specific details. +Redis Cloud provides encryption for all data stored on disk in Redis databases. See our [encryption at rest documentation]({{< relref "/operate/rc/security/encryption-at-rest.md" >}}) for specific details. diff --git a/content/operate/rs/installing-upgrading/quickstarts/docker-quickstart.md b/content/operate/rs/installing-upgrading/quickstarts/docker-quickstart.md index 72878551be..a77debbe13 100644 --- a/content/operate/rs/installing-upgrading/quickstarts/docker-quickstart.md +++ b/content/operate/rs/installing-upgrading/quickstarts/docker-quickstart.md @@ -9,6 +9,7 @@ description: Set up a development or test deployment of Redis Enterprise Softwar using Docker. linkTitle: Docker quickstart weight: 2 +aliases: /operate/rs/installing-upgrading/get-started-docker/ --- {{< warning >}} Docker containers are currently only supported for development and test environments, not for production. Use [Redis Enterprise on Kubernetes]({{< relref "/operate/kubernetes" >}}) for a supported containerized deployment. diff --git a/content/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-110.md b/content/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-110.md index 93fbc82f9b..e3f231cdac 100644 --- a/content/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-110.md +++ b/content/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-110.md @@ -108,6 +108,10 @@ Redis Enterprise 6.4.2-110 supports open source Redis 6.2 and 6.0. Below is the Redis 6.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a race condition that can be used by another process to bypass desired Unix socket permissions on startup. (Redis 6.2.14) diff --git a/content/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-115.md b/content/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-115.md new file mode 100644 index 0000000000..3d5c4bf7c7 --- /dev/null +++ b/content/operate/rs/release-notes/rs-6-4-2-releases/rs-6-4-2-115.md @@ -0,0 +1,161 @@ +--- +Title: Redis Enterprise Software release notes 6.4.2-115 (Oct 2024) +alwaysopen: false +categories: +- docs +- operate +- rs +compatibleOSSVersion: Redis 6.2.10 +description: RediSearch v2.6.23. RedisBloom v2.4.12. RedisTimeSeries v1.8.15. +linkTitle: 6.4.2-115 (Oct 2024) +weight: 64 +--- + +This is a maintenance release for ​[​Redis Enterprise Software version 6.4.2](https://redis.com/redis-enterprise-software/download-center/software/). + +## Highlights + +This version offers: + +- RediSearch v2.6.23 + +- RedisBloom v2.4.12 + +- RedisTimeSeries v1.8.15 + +## New in this release + +### Enhancements + +#### Redis modules + +Redis Enterprise Software version 6.4.2-115 includes the following Redis Stack modules: + +- [RediSearch v2.6.23]({{< baseurl >}}/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes) + +- [RedisJSON v2.4.7]({{< baseurl >}}/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes) + +- [RedisBloom v2.4.12]({{< baseurl >}}/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes) + +- [RedisGraph v2.10.15]({{< baseurl >}}/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes) + +- [RedisTimeSeries v1.8.15]({{< baseurl >}}/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes) + +## Version changes + +### Supported platforms + +The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility. + +✅ Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules. + +:warning: Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release. + +| Redis Enterprise
major versions | 7.4 | 7.2 | 6.4 | 6.2 | +|---------------------------------|:-----:|:-----:|:-----:|:-----:| +| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 | +| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after
next major release | Feb 2026 | Aug 2025 | Feb 2025 | +| **Platforms** | | | | | +| RHEL 9 &
compatible distros[1](#table-note-1) | ✅ | – | – | – | +| RHEL 8 &
compatible distros[1](#table-note-1) | ✅ | ✅ | ✅ | ✅ | +| RHEL 7 &
compatible distros[1](#table-note-1) | – | :warning: | ✅ | ✅ | +| Ubuntu 20.04[2](#table-note-2) | ✅ | ✅ | ✅ | – | +| Ubuntu 18.04[2](#table-note-2) | :warning: | :warning: | ✅ | ✅ | +| Ubuntu 16.04[2](#table-note-2) | – | :warning: | ✅ | ✅ | +| Amazon Linux 2 | ✅ | ✅ | ✅ | – | +| Amazon Linux 1 | – | ✅ | ✅ | ✅ | +| Kubernetes[3](#table-note-3) | ✅ | ✅ | ✅ | ✅ | +| Docker[4](#table-note-4) | ✅ | ✅ | ✅ | ✅ | + +1. The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported. + +2. The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments. + +3. See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution. + +4. +[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only. + +## Downloads + +The following table shows the MD5 checksums for the available packages: + +| Package | MD5 checksum (6.4.2-115 Oct release) | +|---------|---------------------------------------| +| Ubuntu 16 | 5fb2186abb6c87efebd987ebf827b949 | +| Ubuntu 18 | e8a938c7125fbc7d7f85f0e19d4afafb | +| Red Hat Enterprise Linux (RHEL) 7 | dc646920043bd888299726027d9e9216 | +| Red Hat Enterprise Linux (RHEL) 8 | 54574ca69f2966f7361f281f1ea3b312 | +| Amazon Linux 2 | 8315ba719f1549e8bf423a9db004d49c | + +## Security + +#### Open source Redis security fixes compatibility + +As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs. + +Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis. + +Redis Enterprise 6.4.2-115 supports open source Redis 6.2 and 6.0. Below is the list of open source Redis CVEs fixed by version. + +Redis 6.2.x: + +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + +- (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a +race condition that can be used by another process to bypass desired Unix +socket permissions on startup. (Redis 6.2.14) + +- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12) + +- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11) + +- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9) + +- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, can cause it to hang and consume 100% CPU time. (Redis 6.2.11) + +- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9) + +- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13) + +- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7) + +- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7) + +- (CVE-2021-41099) Integer to heap buffer overflow can occur when handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6) + +- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` can occur when parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6) + +- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5) + +- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6) + +- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6) + +- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6) + +- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6) + +- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6) + +- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6) + +- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4) + +- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3) + +- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3) + +Redis 6.0.x: + +- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20) + +- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19) + +- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18) + +- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis, causing it to hang and consume 100% CPU time. (Redis 6.0.18) + +- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17) diff --git a/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-109.md b/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-109.md index 9febeda6c8..18e3a69c97 100644 --- a/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-109.md +++ b/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-109.md @@ -104,12 +104,20 @@ Redis Enterprise 7.2.4-109 supports open source Redis 7.2, 6.2, and 6.0. Below i Redis 7.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1) Redis 7.0.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13) @@ -140,6 +148,10 @@ Redis 7.0.x: Redis 6.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a race condition that can be used by another process to bypass desired Unix socket permissions on startup. (Redis 6.2.14) diff --git a/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md b/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md index ac25a6daa7..5454815185 100644 --- a/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md +++ b/content/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52.md @@ -257,7 +257,7 @@ A preview of triggers and functions is available. Triggers and functions provide support for running JavaScript functions inside the Redis process. These functions can be executed on-demand, by an event-driven trigger, or by a stream processing trigger. -Try it out with the [triggers and functions quick start]({{< relref "/operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/" >}}quick_start/). +Try it out with the [triggers and functions quick start]({{< relref "operate/oss_and_stack/stack-with-enterprise/deprecated-features/triggers-and-functions/quick_start_ri/" >}}). {{}} - The preview version of triggers and functions is not intended for production use since the API might change in the future and potentially cause application issues when upgrading to a later version. diff --git a/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-169.md b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-169.md index 4610d44ff4..2ac4e1c5c2 100644 --- a/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-169.md +++ b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-169.md @@ -148,12 +148,20 @@ Redis Enterprise 7.4.2 supports Redis 7.2, 6.2, and 6.0. Below is the list of Re Redis 7.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1) Redis 7.0.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13) @@ -184,6 +192,10 @@ Redis 7.0.x: Redis 6.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a race condition that can be used by another process to bypass desired Unix socket permissions on startup. (Redis 6.2.14) diff --git a/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-216.md b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-216.md index 5a110942d9..d172d01f79 100644 --- a/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-216.md +++ b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-2-216.md @@ -139,12 +139,20 @@ Redis Enterprise 7.4.2 supports Redis 7.2, 6.2, and 6.0. Below is the list of Re Redis 7.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1) Redis 7.0.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13) @@ -175,6 +183,10 @@ Redis 7.0.x: Redis 6.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-45145) The wrong order of listen(2) and chmod(2) calls creates a race condition that can be used by another process to bypass desired Unix socket permissions on startup. (Redis 6.2.14) diff --git a/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-102.md b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-102.md new file mode 100644 index 0000000000..0a5260f202 --- /dev/null +++ b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-102.md @@ -0,0 +1,318 @@ +--- +Title: Redis Enterprise Software release notes 7.4.6-102 (October 2024) +alwaysopen: false +categories: +- docs +- operate +- rs +compatibleOSSVersion: Redis 7.2.4 +description: Updated module feature sets with later versions of RediSearch and RedisTimeSeries. +linkTitle: 7.4.6-102 (October 2024) +weight: 64 +aliases: +--- + +This is a maintenance release for ​[​Redis Enterprise Software version 7.4.6](https://redis.com/redis-enterprise-software/download-center/software/). + +## Highlights + +This version offers: + +- Updated module feature sets with later versions of RediSearch and RedisTimeSeries + +## New in this release + +#### Redis module feature sets + +Redis Enterprise comes packaged with several modules. As of version 7.4.2, Redis Enterprise includes two feature sets, compatible with different Redis database versions. + +Bundled Redis modules compatible with Redis database version 7.2: + +- [RediSearch 2.8.19]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.8-release-notes.md" >}}) + +- [RedisJSON 2.6.13]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.6-release-notes.md" >}}) + +- [RedisTimeSeries 1.10.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.10-release-notes.md" >}}) + +- [RedisBloom 2.6.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.6-release-notes.md" >}}) + +- [RedisGears 2.0.20 preview](https://github.com/RedisGears/RedisGears/releases/tag/v2.0.20-m21): The RedisGears preview will not be promoted to GA and will be removed in a future release. + +Bundled Redis modules compatible with Redis database versions 6.0 and 6.2: + +- [RediSearch 2.6.23]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisearch/redisearch-2.6-release-notes.md" >}}) + +- [RedisJSON 2.4.9]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisjson/redisjson-2.4-release-notes.md" >}}) + +- [RedisTimeSeries 1.8.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redistimeseries/redistimeseries-1.8-release-notes.md" >}}) + +- [RedisBloom 2.4.12]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisbloom/redisbloom-2.4-release-notes.md" >}}) + +- [RedisGraph v2.10.15]({{< relref "/operate/oss_and_stack/stack-with-enterprise/release-notes/redisgraph/redisgraph-2.10-release-notes.md" >}}): RedisGraph end-of-life has been announced and will be removed in a future release. See the [RedisGraph end-of-life announcement](https://redis.io/blog/redisgraph-eol/) for more details. + +## Version changes + +### Product lifecycle updates + +#### End-of-life policy extension + +The end-of-life policy for Redis Enterprise Software versions 6.2 and later has been extended to 24 months after the formal release of the subsequent major version. For the updated end-of-life schedule, see the [Redis Enterprise Software product lifecycle]({{}}). + +#### Supported upgrade paths + +Redis Enterprise Software versions 6.2.4 and 6.2.8 do not support direct upgrades beyond version 7.4.x. Versions 6.2.10, 6.2.12, and 6.2.18 are part of the [upgrade path]({{}}). To upgrade from 6.2.4 or 6.2.8 to versions later than 7.4.x, an intermediate upgrade is required. + +The next major Redis Enterprise Software release will still bundle Redis database version 6.2 and allow database upgrades from Redis database version 6.2 to 7.x. + +See the [Redis Enterprise Software product lifecycle]({{}}) for more information about release numbers. + +### Deprecations + +#### Legacy UI deprecation + +The legacy UI is deprecated in favor of the new Cluster Manager UI and will be removed in a future release. + +#### Redis 6.0 database deprecation + +Redis database version 6.0 is deprecated as of Redis Enterprise Software version 7.4.2 and will be removed in a future release. + +To prepare for the future removal of Redis 6.0: + +- For Redis Enterprise 6.2.* clusters, upgrade Redis 6.0 databases to Redis 6.2. See the [Redis 6.2 release notes](https://raw.githubusercontent.com/redis/redis/6.2/00-RELEASENOTES) for the list of changes. + +- For Redis Enterprise 7.2.4 and 7.4.x clusters, upgrade Redis 6.0 databases to Redis 7.2. Before you upgrade your databases, see the list of [Redis 7.2 breaking changes]({{< relref "/operate/rs/release-notes/rs-7-2-4-releases/rs-7-2-4-52#redis-72-breaking-changes" >}}) and update any applications that connect to your database to handle these changes. + +#### End of triggers and functions preview + +The [triggers and functions]({{}}) (RedisGears) preview has been discontinued. + +- Commands such as `TFCALL`, `TFCALLASYNC`, and `TFUNCTION` will be deprecated and will return error messages. + +- Any JavaScript functions stored in Redis will be removed. + +- JavaScript-based triggers will be blocked. + +- Lua functions and scripts will not be affected. + +If your database currently uses triggers and functions, you need to: + +1. Adjust your applications to accommodate these changes. + +1. Delete all triggers and functions libraries from your existing database: + + 1. Run `TFUNCTION LIST`. + + 1. Copy all library names. + + 1. Run `TFUNCTION DELETE` for each library in the list. + + If any triggers and functions libraries remain in the database, the RDB snapshot won't load on a cluster without RedisGears. + +1. Migrate your database to a new database without the RedisGears module. + +#### RedisGraph end of life + +Redis has announced the end of life for RedisGraph. Redis will continue to support all RedisGraph customers, including releasing patch versions until January 31, 2025. + +See the [RedisGraph end-of-life announcement](https://redis.com/blog/redisgraph-eol/) for more details. + +### Upcoming changes + +#### Default image change for Redis Enterprise Software containers + +Starting with the next major version, Redis Enterprise Software containers with the image tag `x.y.z-build` will be based on RHEL instead of Ubuntu. + +This change will only affect you if you use containers outside the official [Redis Enterprise for Kubernetes]({{}}) product and use Ubuntu-specific commands. + +To use Ubuntu-based images after this change, you can specify the operating system suffix in the image tag. For example, use the image tag `7.4.2-216.focal` instead of `7.4.2-216`. + +### Supported platforms + +The following table provides a snapshot of supported platforms as of this Redis Enterprise Software release. See the [supported platforms reference]({{< relref "/operate/rs/references/supported-platforms" >}}) for more details about operating system compatibility. + +✅ Supported – The platform is supported for this version of Redis Enterprise Software and Redis Stack modules. + +:warning: Deprecation warning – The platform is still supported for this version of Redis Enterprise Software, but support will be removed in a future release. + +| Redis Enterprise
major versions | 7.4 | 7.2 | 6.4 | 6.2 | +|---------------------------------|:-----:|:-----:|:-----:|:-----:| +| **Release date** | Feb 2024 | Aug 2023 | Feb 2023 | Aug 2021 | +| [**End-of-life date**]({{< relref "/operate/rs/installing-upgrading/product-lifecycle#endoflife-schedule" >}}) | Determined after
next major release | Feb 2026 | Aug 2025 | Feb 2025 | +| **Platforms** | | | | | +| RHEL 9 &
compatible distros[1](#table-note-1) | ✅ | – | – | – | +| RHEL 8 &
compatible distros[1](#table-note-1) | ✅ | ✅ | ✅ | ✅ | +| RHEL 7 &
compatible distros[1](#table-note-1) | – | :warning: | ✅ | ✅ | +| Ubuntu 20.04[2](#table-note-2) | ✅ | ✅ | ✅ | – | +| Ubuntu 18.04[2](#table-note-2) | :warning: | :warning: | ✅ | ✅ | +| Ubuntu 16.04[2](#table-note-2) | – | :warning: | ✅ | ✅ | +| Amazon Linux 2 | ✅ | ✅ | ✅ | – | +| Amazon Linux 1 | – | ✅ | ✅ | ✅ | +| Kubernetes[3](#table-note-3) | ✅ | ✅ | ✅ | ✅ | +| Docker[4](#table-note-4) | ✅ | ✅ | ✅ | ✅ | + +1. The RHEL-compatible distributions CentOS, CentOS Stream, Alma, and Rocky are supported if they have full RHEL compatibility. Oracle Linux running the Red Hat Compatible Kernel (RHCK) is supported, but the Unbreakable Enterprise Kernel (UEK) is not supported. + +2. The server version of Ubuntu is recommended for production installations. The desktop version is only recommended for development deployments. + +3. See the [Redis Enterprise for Kubernetes documentation]({{< relref "/operate/kubernetes/reference/supported_k8s_distributions" >}}) for details about support per version and Kubernetes distribution. + +4. +[Docker images]({{< relref "/operate/rs/installing-upgrading/quickstarts/docker-quickstart" >}}) of Redis Enterprise Software are certified for development and testing only. + +## Downloads + +The following table shows the SHA256 checksums for the available packages: + +| Package | SHA256 checksum (7.4.6-102 October release) | +|---------|---------------------------------------| +| Ubuntu 18 | f4e6af466b565e59d2e3fb1f5f0c70b7903564a0f1a45cc5a6816caf20059f93 | +| Ubuntu 20 | 9f10ed232a5655fdc5b46d2dd98157449484fb03290c8c71994cf29b50c4b4a7 | +| Red Hat Enterprise Linux (RHEL) 8 | 412a2244e5fd464382acccf811a221671c120fcb51d00bf6bc3089b6f9ad034e | +| Red Hat Enterprise Linux (RHEL) 9 | b4fc25f6a812fe05ab990049f7f6f8a22932c5d8c507c475455802009ed5acca | +| Amazon Linux 2 | ab3dafdc46823548a6a4a2870be1db21cd2d907533bd0fddf59a895b94c00863 | + +## Known issues + +- RS131972: Creating an ACL that contains a line break in the Cluster Manager UI can cause shard migration to fail due to ACL errors. + +- RS61676: Full chain certificate update fails if any certificate in the chain does not have a Common Name (CN). + +- RS119958: The `debuginfo` script fails with the error `/bin/tar: Argument list too long` if there are too many RocksDB log files. This issue only affects clusters with Auto Tiering. + +## Known limitations + +#### New Cluster Manager UI limitations + +The following legacy UI features are not yet available in the new Cluster Manager UI: + +- Remove a node. + + Use the REST API or legacy UI instead. See [Remove a cluster node]({{< relref "/operate/rs/clusters/remove-node" >}}) for instructions. + +- Purge an Active-Active instance. + + Use [`crdb-cli crdb purge-instance`]({{< relref "/operate/rs/references/cli-utilities/crdb-cli/crdb/purge-instance" >}}) instead. + +- Search and export the log. + +#### OpenSSL compatibility issue for 7.4.2 modules on Amazon Linux 2 + +Due to an OpenSSL 1.1 compatibility issue between modules and clusters, Redis Enterprise Software version 7.4.2-54 is not fully supported on Amazon Linux 2 clusters with databases that use the following modules: RedisGears, RediSearch, or RedisTimeSeries. + +This issue will be fixed in a future maintenance release. + +#### RedisGraph prevents upgrade to RHEL 9 + +You cannot upgrade from a prior RHEL version to RHEL 9 if the Redis Enterprise cluster contains a RedisGraph module, even if unused by any database. The [RedisGraph module has reached End-of-Life](https://redis.com/blog/redisgraph-eol/) and is completely unavailable in RHEL 9. + +## Security + +#### Open source Redis security fixes compatibility + +As part of Redis's commitment to security, Redis Enterprise Software implements the latest [security fixes](https://github.com/redis/redis/releases) available with [open source Redis](https://github.com/redis/redis). Redis Enterprise has already included the fixes for the relevant CVEs. + +Some CVEs announced for open source Redis do not affect Redis Enterprise due to different or additional functionality available in Redis Enterprise that is not available in open source Redis. + +Redis Enterprise 7.4.6-102 supports open source Redis 7.2, 6.2, and 6.0. Below is the list of open source Redis CVEs fixed by version. + +Redis 7.2.x: + +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + +- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. + +- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1) + +Redis 7.0.x: + +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + +- (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. + +- (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13) + +- (CVE-2023-36824) Extracting key names from a command and a list of arguments may, in some cases, trigger a heap overflow and result in reading random heap memory, heap corruption, and potentially remote code execution. Specifically: using `COMMAND GETKEYS*` and validation of key names in ACL rules. (Redis 7.0.12) + +- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 7.0.11) + +- (CVE-2023-28425) Specially crafted `MSETNX` commands can lead to assertion and denial-of-service. (Redis 7.0.10) + +- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 7.0.9) + +- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 7.0.8) + +- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 7.0.9) + +- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 7.0.8) + +- (CVE-2022-35951) Executing an `XAUTOCLAIM` command on a stream key in a specific state, with a specially crafted `COUNT` argument, may cause an integer overflow, a subsequent heap overflow, and potentially lead to remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.5) + +- (CVE-2022-31144) A specially crafted `XAUTOCLAIM` command on a stream key in a specific state may result in heap overflow and potentially remote code execution. The problem affects Redis versions 7.0.0 or newer. (Redis 7.0.4) + +- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 7.0.12) + +- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 7.0.0) + +- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 7.0.0) + +Redis 6.2.x: + +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + +- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12) + +- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11) + +- (CVE-2023-22458) Integer overflow in the Redis `HRANDFIELD` and `ZRANDMEMBER` commands can lead to denial-of-service. (Redis 6.2.9) + +- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.2.11) + +- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.2.9) + +- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.2.13) + +- (CVE-2022-24736) An attacker attempting to load a specially crafted Lua script can cause NULL pointer dereference which will result in a crash of the `redis-server` process. This issue affects all versions of Redis. (Redis 6.2.7) + +- (CVE-2022-24735) By exploiting weaknesses in the Lua script execution environment, an attacker with access to Redis can inject Lua code that will execute with the (potentially higher) privileges of another Redis user. (Redis 6.2.7) + +- (CVE-2021-41099) Integer to heap buffer overflow handling certain string commands and network payloads, when `proto-max-bulk-len` is manually configured to a non-default, very large value. (Redis 6.2.6) + +- (CVE-2021-32762) Integer to heap buffer overflow issue in `redis-cli` and `redis-sentinel` parsing large multi-bulk replies on some older and less common platforms. (Redis 6.2.6) + +- (CVE-2021-32761) An integer overflow bug in Redis version 2.2 or newer can be exploited using the `BITFIELD` command to corrupt the heap and potentially result with remote code execution. (Redis 6.2.5) + +- (CVE-2021-32687) Integer to heap buffer overflow with intsets, when `set-max-intset-entries` is manually configured to a non-default, very large value. (Redis 6.2.6) + +- (CVE-2021-32675) Denial Of Service when processing RESP request payloads with a large number of elements on many connections. (Redis 6.2.6) + +- (CVE-2021-32672) Random heap reading issue with Lua Debugger. (Redis 6.2.6) + +- (CVE-2021-32628) Integer to heap buffer overflow handling ziplist-encoded data types, when configuring a large, non-default value for `hash-max-ziplist-entries`, `hash-max-ziplist-value`, `zset-max-ziplist-entries` or `zset-max-ziplist-value`. (Redis 6.2.6) + +- (CVE-2021-32627) Integer to heap buffer overflow issue with streams, when configuring a non-default, large value for `proto-max-bulk-len` and `client-query-buffer-limit`. (Redis 6.2.6) + +- (CVE-2021-32626) Specially crafted Lua scripts may result with Heap buffer overflow. (Redis 6.2.6) + +- (CVE-2021-32625) An integer overflow bug in Redis version 6.0 or newer can be exploited using the STRALGO LCS command to corrupt the heap and potentially result with remote code execution. This is a result of an incomplete fix by CVE-2021-29477. (Redis 6.2.4) + +- (CVE-2021-29478) An integer overflow bug in Redis 6.2 could be exploited to corrupt the heap and potentially result with remote code execution. The vulnerability involves changing the default set-max-intset-entries configuration value, creating a large set key that consists of integer values and using the COPY command to duplicate it. The integer overflow bug exists in all versions of Redis starting with 2.6, where it could result with a corrupted RDB or DUMP payload, but not exploited through COPY (which did not exist before 6.2). (Redis 6.2.3) + +- (CVE-2021-29477) An integer overflow bug in Redis version 6.0 or newer could be exploited using the STRALGO LCS command to corrupt the heap and potentially result in remote code execution. The integer overflow bug exists in all versions of Redis starting with 6.0. (Redis 6.2.3) + +Redis 6.0.x: + +- (CVE-2022-24834) A specially crafted Lua script executing in Redis can trigger a heap overflow in the cjson and cmsgpack libraries, and result in heap corruption and potentially remote code execution. The problem exists in all versions of Redis with Lua scripting support, starting from 2.6, and affects only authenticated and authorized users. (Redis 6.0.20) + +- (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.0.19) + +- (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.0.18) + +- (CVE-2022-36021) String matching commands (like `SCAN` or `KEYS`) with a specially crafted pattern to trigger a denial-of-service attack on Redis can cause it to hang and consume 100% CPU time. (Redis 6.0.18) + +- (CVE-2022-35977) Integer overflow in the Redis `SETRANGE` and `SORT`/`SORT_RO` commands can drive Redis to OOM panic. (Redis 6.0.17) diff --git a/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-22.md b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-22.md index 83e10e9d49..d6f1d273b9 100644 --- a/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-22.md +++ b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-22.md @@ -205,12 +205,20 @@ Redis Enterprise 7.4.6-22 supports open source Redis 7.2, 6.2, and 6.0. Below is Redis 7.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1) Redis 7.0.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13) @@ -241,6 +249,10 @@ Redis 7.0.x: Redis 6.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12) - (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11) diff --git a/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-77.md b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-77.md index 0f9ffe6c14..2d2a1516a4 100644 --- a/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-77.md +++ b/content/operate/rs/release-notes/rs-7-4-2-releases/rs-7-4-6-77.md @@ -229,12 +229,20 @@ Redis Enterprise 7.4.6-77 supports open source Redis 7.2, 6.2, and 6.0. Below is Redis 7.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.2.1) Redis 7.0.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-41056) In some cases, Redis may incorrectly handle resizing of memory buffers, which can result in incorrect accounting of buffer sizes and lead to heap overflow and potential remote code execution. - (CVE-2023-41053) Redis does not correctly identify keys accessed by `SORT_RO` and, as a result, may grant users executing this command access to keys that are not explicitly authorized by the ACL configuration. (Redis 7.0.13) @@ -265,6 +273,10 @@ Redis 7.0.x: Redis 6.2.x: +- (CVE-2024-31449) An authenticated user may use a specially crafted Lua script to trigger a stack buffer overflow in the bit library, which may potentially lead to remote code execution. + +- (CVE-2024-31228) An authenticated user can trigger a denial-of-service by using specially crafted, long string match patterns on supported commands such as `KEYS`, `SCAN`, `PSUBSCRIBE`, `FUNCTION LIST`, `COMMAND LIST`, and ACL definitions. Matching of extremely long patterns may result in unbounded recursion, leading to stack overflow and process crashes. + - (CVE-2023-28856) Authenticated users can use the `HINCRBYFLOAT` command to create an invalid hash field that will crash Redis on access. (Redis 6.2.12) - (CVE-2023-25155) Specially crafted `SRANDMEMBER`, `ZRANDMEMBER`, and `HRANDFIELD` commands can trigger an integer overflow, resulting in a runtime assertion and termination of the Redis server process. (Redis 6.2.11) diff --git a/insert_url_frontmatter.bash b/insert_url_frontmatter.bash new file mode 100755 index 0000000000..cbbd7c5791 --- /dev/null +++ b/insert_url_frontmatter.bash @@ -0,0 +1,16 @@ +#!/bin/bash +dir="$1" +pages="$(find $dir -name "*.md")" + +for page in $pages; do + if [[ "$page" =~ \/_index.md$ ]]; then + url=$(sed "s/_index.md$/'/; s/^content/'/"<<< $page) + else + url=$(sed "s/.md$/\/'/; s/^content/'/"<<< $page) + fi + # skip if url property is already present + if ! grep -q "$url" $page; then + awk -v url="$url" '$1 == "---" {delim++; if (delim==2){printf "%s\n", "url: "url}} {print}' $page > tmp.md + mv tmp.md $page + fi +done \ No newline at end of file diff --git a/layouts/operate/list.html b/layouts/operate/list.html index 674d0c8d99..d3b03e7237 100644 --- a/layouts/operate/list.html +++ b/layouts/operate/list.html @@ -54,5 +54,6 @@

{{ partial "docs-toc.html" . }} + {{ partial "scripts.html" . }} {{ end }} diff --git a/layouts/operate/single.html b/layouts/operate/single.html index 36b11cc3b9..21f59282a7 100644 --- a/layouts/operate/single.html +++ b/layouts/operate/single.html @@ -40,5 +40,6 @@

{{ partial "docs-toc.html" . }} + {{ partial "scripts.html" . }} {{ end }} diff --git a/layouts/partials/docs-nav.html b/layouts/partials/docs-nav.html index 249031067f..f21c919ad3 100644 --- a/layouts/partials/docs-nav.html +++ b/layouts/partials/docs-nav.html @@ -17,7 +17,31 @@ {{ end -}} {{.LinkTitle}} + {{if (eq (.Params.linkTitle) "Redis for Kubernetes")}} + + {{else if (eq (.Params.linkTitle) "Redis Software")}} + + + {{end}} {{ if and (gt (len $childPages) 0) (or $isActive $isActivePath)}}
    {{ template "li" (dict "page" $page "pages" $childPages) }} diff --git a/layouts/partials/scripts.html b/layouts/partials/scripts.html new file mode 100644 index 0000000000..af94157f71 --- /dev/null +++ b/layouts/partials/scripts.html @@ -0,0 +1,81 @@ + + + \ No newline at end of file diff --git a/static/images/rc/subscription-new-flexible-version-section.png b/static/images/rc/subscription-new-flexible-version-section.png index 8f585a481f..396f4fe716 100644 Binary files a/static/images/rc/subscription-new-flexible-version-section.png and b/static/images/rc/subscription-new-flexible-version-section.png differ