feat: updated documentation with a new way to configure redis connect…

…ions

guides/hosting/infrastructure/redis.md

@@ -47,10 +47,29 @@ As the data is critical, it is important to use a key eviction policy that will
 
 The cart, number range, lock store and increment data is what should be stored in this instance.
 
+## Configuration
+
+Starting with v6.6.8.0 Shopware supports configuring different reusable Redis connections in the`config/packages/shopware.yaml` file under the `shopware` section:
+
+```yaml
+shopware:
+    # ...
+    redis:
+        connections:
+            ephemeral:
+                dsn: 'redis://host1:port/dbindex'
+            persistent:
+                dsn: 'redis://host2:port/dbindex?persistent=1'
+```
+
+Connection names should reflect the actual connection purpose/type and be unique. Also, the names are used as part of the service names in the container, so they should follow the service naming conventions. After defining connections, you can reference them by name in the configuration of different subsystems.
+
 <PageRef page="../performance/cart-storage" />
 
 <PageRef page="../performance/number-ranges" />
 
 <PageRef page="../performance/lock-store" />
 
 <PageRef page="../performance/increment" />
+
+<PageRef page="../performance/performance-tweaks#delayed-invalidation" />

guides/hosting/performance/cart-storage.md

@@ -16,11 +16,33 @@ Redis is better suited in high-throughput scenarios, therefore you should use Re
 
 To use Redis, create a `config/packages/shopware.yml` file with the following content:
 
+<Tabs>
+<Tab title="Before v.6.6.8.0">
+
 ```yaml
 shopware:
   cart:
     redis_url: 'redis://host:port/dbindex?persistent=1'
 ```
+</Tab>
+
+<Tab title="Since v.6.6.8.0">
+
+```yaml
+shopware:
+    redis:
+        connections:
+            persistent:
+                dsn: 'redis://host:port/dbindex?persistent=1'
+    cart:
+        storage:
+            type: 'redis'
+            config:
+                 connection: 'persistent'
+```
+</Tab>
+</Tabs>
+
 It is recommended to use a persistent Redis connection to avoid connection issues in high-load scenarios.
 
 ## Migrating between storages

guides/hosting/performance/increment.md

@@ -20,6 +20,9 @@ Shopware uses the `increment` table to store such information by default. When m
 
 To use Redis, create a `config/packages/shopware.yml` file with the following content
 
+<Tabs>
+<Tab title="Before v.6.6.8.0">
+
 ```yaml
 shopware:
     increment:
@@ -33,6 +36,30 @@ shopware:
           config:
             url: 'redis://host:port/dbindex'
 ```
+</Tab>
+
+<Tab title="Since v.6.6.8.0">
+
+```yaml
+shopware:
+    redis:
+        connections:
+            persistent:
+                dsn: 'redis://host:port/dbindex?persistent=1'
+
+    increment:
+        user_activity:
+            type: 'redis'
+            config:
+                connection: 'persistent'
+
+        message_queue:
+            type: 'redis'
+            config:
+                connection: 'persistent'
+```
+</Tab>
+</Tabs>
 
 ### Redis configuration
 
@@ -50,8 +77,8 @@ To disable it, create a `config/packages/shopware.yml` file with the following c
 shopware:
     increment:
         user_activity:
-          type: 'array'
+            type: 'array'
 
         message_queue:
-          type: 'array'
+            type: 'array'
 ```

guides/hosting/performance/number-ranges.md

@@ -18,12 +18,32 @@ Redis offers better support for atomic increments than the database. Therefore t
 
 To use Redis, create a `config/packages/shopware.yml` file with the following content:
 
+<Tabs>
+<Tab title="Before v.6.6.8.0">
+
+```yaml
+shopware:
+    number_range:
+        increment_storage: "Redis"
+        redis_url: 'redis://host:port/dbindex'
+```
+</Tab>
+
+<Tab title="Since v.6.6.8.0">
+
 ```yaml
 shopware:
-  number_range:
-    increment_storage: "Redis"
-    redis_url: 'redis://host:port/dbindex'
+    redis:
+        connections:
+            persistent:
+                dsn: 'redis://host:port/dbindex?persistent=1'
+    number_range:
+        increment_storage: 'redis'
+        config:
+            connection: 'persistent'
 ```
+</Tab>
+</Tabs>
 
 ### Redis configuration
 

guides/hosting/performance/performance-tweaks.md

@@ -45,7 +45,7 @@ shopware:
             delay: 1
             delay_options:
                 storage: redis
-                dsn: 'redis://host:port/dbindex'
+                connection: 'ephemeral' # connection name from redis configuration
 ```
 
 ## MySQL configuration
@@ -92,23 +92,7 @@ If you ever wonder why it is in `prod`, take a look into the [Symfony configurat
 ## Increment storage
 
 The [Increment storage](../performance/increment) is used to store the state and display it in the Administration.
-This storage increments or decrements a given key in a transaction-safe way, which causes locks upon the storage. Therefore, we recommend moving this source of server load to a separate Redis:
-
-```yaml
-# config/packages/prod/shopware.yaml
-shopware:
-    increment:
-        user_activity:
-          type: 'redis'
-          config:
-            url: 'redis://host:port/dbindex'
-
-        message_queue:
-          type: 'redis'
-          config:
-            url: 'redis://host:port/dbindex'
-```
-
+This storage increments or decrements a given key in a transaction-safe way, which causes locks upon the storage. Therefore, we recommend moving this source of server load to a separate Redis, as described in [Increment storage Redis configuration](./increment#redis-configuration).  
 If you don't need such functionality, it is highly recommended that you disable this behavior by using `array` as a type.
 
 ## Lock storage
@@ -129,15 +113,7 @@ The generation of the number ranges is an **atomic** operation, which guarantees
 
 By default, the number range states are stored in the database.
 In scenarios where high throughput is required (e.g., thousands of orders per minute), the database can become a performance bottleneck because of the requirement for atomicity.
-Redis offers better support for atomic increments than the database. Therefore, the number ranges should be stored in Redis in such scenarios.
-
-```yaml
-# config/packages/prod/shopware.yaml
-shopware:
-  number_range:
-    increment_storage: "Redis"
-    redis_url: 'redis://host:port/dbindex'
-```
+Redis offers better support for atomic increments than the database. Therefore, the number ranges should be stored in Redis in such scenarios, see [Number Ranges - using Redis as a storage](./number-ranges#using-redis-as-storage).
 
 ## Sending mails with the Queue
 

guides/plugins/plugins/redis.md

@@ -0,0 +1,77 @@
+---
+nav:
+  title: Redis
+  position: 45
+
+---
+
+# Redis
+
+Starting with Shopware v6.6.8.0, Redis support has been improved, giving you more flexibility in how you use it in your projects and plugins.
+
+Once you've set up your Redis connections as explained in the  [Redis configuration](../../hosting/infrastructure/redis) guide, you can access them in your code using the following methods:
+
+1. Inject `Shopware\Core\Framework\Adapter\Redis\RedisConnectionProvider` and retrieve connections by name:
+
+    ```xml
+    <service id="MyCustomService">
+        <argument type="service" id="Shopware\Core\Framework\Adapter\Redis\RedisConnectionProvider" />
+        <argument>%myservice.redis_connection_name%</argument>
+    </service>
+    ```
+
+    ```php
+    class MyCustomService
+    { 
+        public function __construct (
+            private RedisConnectionProvider $redisConnectionProvider,
+            string $connectionName,
+        ) { }
+
+        public function doSomething()
+        {
+            if ($this->redisConnectionProvider->hasConnection($this->connectionName)) {
+                $connection = $this->redisConnectionProvider->getConnection($this->connectionName);
+                // use connection
+            }
+        }
+    }
+    ```
+
+2. Use `Shopware\Core\Framework\Adapter\Redis\RedisConnectionProvider` as factory to define custom services:
+
+    ```xml
+    <service id="my.custom.redis_connection" class="Redis">
+        <factory service="Shopware\Core\Framework\Adapter\Redis\RedisConnectionProvider" method="getConnection" />
+        <argument>%myservice.redis_connection_name%</argument>
+    </service>
+
+    <service id="MyCustomService">
+        <argument type="service" id="my.custom.redis_connection" />
+    </service>
+    ```
+
+    ```php
+    class MyCustomService
+    { 
+        public function __construct (
+            private Redis $redisConnection,
+        ) { }
+
+        public function doSomething()
+        {
+            // use connection
+        }
+    }
+    ```
+   This approach is especially useful when you want multiple services to share the same Redis connection.
+
+3. Inject connection directly by name:
+    ```xml
+    <service id="MyCustomService">
+        <argument type="service" id="shopware.redis.connection.connection_name" />
+    </service>
+    ```
+   Be cautious with this approach! If you change the Redis connection names in your configuration, it will cause container build errors.
+
+Keep in mind that Redis is an optional dependency in Shopware and might not be available in all installations.