Ecotone
SponsorBlogGithubSupport and ContactCommunity Channel
  • About
  • Installation
  • How to use
    • CQRS PHP
    • Event Handling PHP
    • Aggregates & Sagas
    • Scheduling in PHP
    • Asynchronous PHP
    • Event Sourcing PHP
    • Microservices PHP
    • Resiliency and Error Handling
    • Laravel Demos
    • Symfony Demos
      • Doctrine ORM
  • Tutorial
    • Before we start tutorial
    • Lesson 1: Messaging Concepts
    • Lesson 2: Tactical DDD
    • Lesson 3: Converters
    • Lesson 4: Metadata and Method Invocation
    • Lesson 5: Interceptors
    • Lesson 6: Asynchronous Handling
  • Enterprise
  • Modelling
    • Introduction
    • Message Bus and CQRS
      • CQRS Introduction - Commands
        • Query Handling
        • Event Handling
      • Aggregate Introduction
        • Aggregate Command Handlers
        • Aggregate Query Handlers
        • Aggregate Event Handlers
        • Advanced Aggregate creation
      • Repositories Introduction
      • Business Interface
        • Introduction
        • Business Repository
        • Database Business Interface
          • Converting Parameters
          • Converting Results
      • Saga Introduction
      • Identifier Mapping
    • Extending Messaging (Middlewares)
      • Message Headers
      • Interceptors (Middlewares)
        • Additional Scenarios
      • Intercepting Asynchronous Endpoints
      • Extending Message Buses (Gateways)
    • Event Sourcing
      • Installation
      • Event Sourcing Introduction
        • Working with Event Streams
        • Event Sourcing Aggregates
          • Working with Aggregates
          • Applying Events
          • Different ways to Record Events
        • Working with Metadata
        • Event versioning
        • Event Stream Persistence
          • Event Sourcing Repository
          • Making Stream immune to changes
          • Snapshoting
          • Persistence Strategies
          • Event Serialization and PII Data (GDPR)
      • Projection Introduction
        • Configuration
        • Choosing Event Streams for Projection
        • Executing and Managing
          • Running Projections
          • Projection CLI Actions
          • Access Event Store
        • Projections with State
        • Emitting events
    • Recovering, Tracing and Monitoring
      • Resiliency
        • Retries
        • Error Channel and Dead Letter
          • Dbal Dead Letter
        • Idempotent Consumer (Deduplication)
        • Resilient Sending
        • Outbox Pattern
        • Concurrency Handling
      • Message Handling Isolation
      • Ecotone Pulse (Service Dashboard)
    • Asynchronous Handling and Scheduling
      • Asynchronous Message Handlers
      • Asynchronous Message Bus (Gateways)
      • Delaying Messages
      • Time to Live
      • Message Priority
      • Scheduling
      • Dynamic Message Channels
    • Distributed Bus and Microservices
      • Distributed Bus
        • Distributed Bus with Service Map
          • Configuration
          • Custom Features
          • Non-Ecotone Application integration
          • Testing
        • AMQP Distributed Bus (RabbitMQ)
          • Configuration
        • Distributed Bus Interface
      • Message Consumer
      • Message Publisher
    • Business Workflows
      • The Basics - Stateless Workflows
      • Stateful Workflows - Saga
      • Handling Failures
    • Testing Support
      • Testing Messaging
      • Testing Aggregates and Sagas with Message Flows
      • Testing Event Sourcing Applications
      • Testing Asynchronous Messaging
  • Messaging and Ecotone In Depth
    • Overview
    • Multi-Tenancy Support
      • Getting Started
        • Any Framework Configuration
        • Symfony and Doctrine ORM
        • Laravel
      • Different Scenarios
        • Hooking into Tenant Switch
        • Shared and Multi Database Tenants
        • Accessing Current Tenant in Message Handler
        • Events and Tenant Propagation
        • Multi-Tenant aware Dead Letter
      • Advanced Queuing Strategies
    • Document Store
    • Console Commands
    • Messaging concepts
      • Message
      • Message Channel
      • Message Endpoints/Handlers
        • Internal Message Handler
        • Message Router
        • Splitter
      • Consumer
      • Messaging Gateway
      • Inbound/Outbound Channel Adapter
    • Method Invocation And Conversion
      • Method Invocation
      • Conversion
        • Payload Conversion
        • Headers Conversion
    • Service (Application) Configuration
    • Contributing to Ecotone
      • How Ecotone works under the hood
      • Ecotone Phases
      • Registering new Module Package
      • Demo Integration with SQS
        • Preparation
        • Inbound and Outbound Adapters and Message Channel
        • Message Consumer and Publisher
  • Modules
    • Overview
    • Symfony
      • Symfony Configuration
      • Symfony Database Connection (DBAL Module)
      • Doctrine ORM
      • Symfony Messenger Transport
    • Laravel
      • Laravel Configuration
      • Database Connection (DBAL Module)
      • Eloquent
      • Laravel Queues
      • Laravel Octane
    • Ecotone Lite
      • Logging
      • Database Connection (DBAL Module)
    • JMS Converter
    • OpenTelemetry (Tracing and Metrics)
      • Configuration
    • RabbitMQ Support
    • Kafka Support
      • Configuration
      • Message partitioning
      • Usage
    • DBAL Support
    • Amazon SQS Support
    • Redis Support
  • Other
    • Contact, Workshops and Support
Powered by GitBook
On this page
  • Installation
  • Module Powered By
  • Configuration
  • Message Channel
  • Message Channel Configuration
  • Message Publisher
  • Publisher Configuration
  • Message Consumer
  • Consumer Configuration

Was this helpful?

Export as PDF
  1. Modules

Redis Support

Ecotone support for Redis

PreviousAmazon SQS SupportNextContact, Workshops and Support

Last updated 1 year ago

Was this helpful?

Installation

composer require ecotone/redis

Module Powered By

solid and powerful abstraction over asynchronous queues.

Configuration

In order to use Redis Support we need to add ConnectionFactory to our Dependency Container.

# config/services.yaml
Enqueue\Redis\RedisConnectionFactory:
    class: Enqueue\Redis\RedisConnectionFactory
    arguments:
        - "redis://localhost:6379"
use Enqueue\Redis\RedisConnectionFactory;

public function register()
{
     $this->app->singleton(RedisConnectionFactory::class, function () {
         return new RedisConnectionFactory("redis://localhost:6379");
     });
}
use Enqueue\Redis\RedisConnectionFactory;

$application = EcotoneLiteApplication::boostrap(
    [
        RedisConnectionFactory::class => new RedisConnectionFactory("redis://localhost:6379")
    ]
);

We register our RedisConnectionFactory under the class name Enqueue\Redis\RedisConnectionFactory. This will help Ecotone resolve it automatically, without any additional configuration.

Message Channel

To create , we need to create .

use Ecotone\Redis\RedisBackedMessageChannelBuilder;

class MessagingConfiguration
{
    #[ServiceContext] 
    public function orderChannel()
    {
        return RedisBackedMessageChannelBuilder::create("orders");
    }
}

Now orders channel will be available in Messaging System.

Message Channel Configuration

RedisBackedMessageChannelBuilder::create("orders")
    ->withAutoDeclare(false) // do not auto declare queue
    ->withDefaultTimeToLive(1000) // limit TTL of messages

Message Publisher

If you want to publish Message directly to Exchange, you may use of Publisher.

use Ecotone\Redis\Configuration\RedisMessageConsumerConfiguration;

class PublisherConfiguration
{
    #[ServiceContext] 
    public function registerPublisherConfig()
    {
        return 
            RedisMessagePublisherConfiguration::create(
                MessagePublisher::class, // 1
                "delivery", // 2
                "application/json" // 3
            );
    }
}
  1. Reference name - Name under which it will be available in Dependency Container.

  2. Queue name - Name of queue where Message should be published

  3. Default Conversion [Optional] - Default type, payload will be converted to.

Publisher Configuration

RedisMessagePublisherConfiguration::create(queueName: $queueName)
    ->withAutoDeclareQueueOnSend(false) // 1
    ->withHeaderMapper("application.*") // 2
    
  1. withAutoDeclareQueueOnSend - should Ecotone try to declare queue before sending message

  2. withHeaderMapper - On default headers are not send with message. You map provide mapping for headers that should be mapped to Redis Message

Message Consumer

To connect consumer directly to a Redis Queue, we need to provide Ecotone with information, how the Queue is configured.

use Ecotone\Redis\Configuration\RedisMessageConsumerConfiguration;

class ConsumerConfiguration
{
    #[ServiceContext] 
    public function registerConsumerConfig(): array
    {
        return [
            RedisMessageConsumerConfiguration::create("orders_consumer", "orders")
        ];
    }
}
  1. Provides Consumer that will be registered at given name "orders_consumer" and will be polling "orders" queue

Consumer Configuration

$consumerConfiguration = RedisMessageConsumerConfiguration::createDirectExchange
                ->withDeclareOnStartup(false) // do not try to declare queue before consuming first message;
Enqueue
Message Channel
Service Context