Redis Caching & Messaging (Pub/Sub, Streams) · Lektion

Ereignisgesteuerte Architektur

Erkunden Sie, wie Redis Pub/Sub die Kommunikation und Benachrichtigungen in ereignisgesteuerten Microservices unterstützen kann.

Ereignisgesteuerte Architektur ist eine kostenlose Redis Caching & Messaging (Pub/Sub, Streams)-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Redis Caching & Messaging (Pub/Sub, Streams)-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Redis Caching & Messaging (Pub/Sub, Streams)-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

What is Event-Driven Architecture?

Welcome! In this lesson, we'll explore Event-Driven Architecture (EDA) and how Redis Pub/Sub is perfect for it.

EDA is a software design pattern where components communicate by reacting to changes in state, known as events.

Think of it like a news channel: producers publish news (events), and anyone interested (consumers) can tune in.

Key Concepts of EDA

EDA revolves around three main components:

Events: A record of something that happened (e.g., 'user registered', 'order placed'). They are immutable facts.
Event Producers: Services that detect an event and publish it to an event channel.
Event Consumers: Services that subscribe to event channels and react to specific events.

These components communicate indirectly.

Why Use EDA?

EDA offers significant benefits, especially for complex systems:

Loose Coupling: Producers don't need to know about consumers, making services independent.
Scalability: You can easily add new consumers without changing producers.
Real-time Responsiveness: Events are processed as they occur, enabling immediate reactions.
Flexibility: New features can be added by simply creating new consumers.

Redis Pub/Sub as the Event Bus

Redis Pub/Sub acts as an ideal event bus for EDA.

An event bus is the central communication channel for events.
In Redis, channels serve as these event buses.

Producers publish events to a Redis channel, and all interested consumers subscribed to that channel receive the event.

Decoupling Microservices

One of the biggest advantages of EDA with Redis Pub/Sub is decoupling microservices.

Imagine a user registration service. Without EDA, it might directly call an email service, a logging service, etc.

With EDA, the registration service just publishes a 'user registered' event. Email and logging services subscribe and react independently. This makes services easier to build and maintain!

Example: User Registration Event

Let's consider a practical scenario: a user registers on your application.

The User Service (producer) registers the user and then publishes a user:registered event to a Redis channel.

Other services, like a Notification Service or a Analytics Service (consumers), can then subscribe to this channel and perform their tasks.

Producer: Publishing an Event

Here's how a Python service might publish a user:registered event after a new user signs up. Make sure Redis is running!

import redis
import json
import time

r = redis.Redis(decode_responses=True)

def register_user(u_id, name, mail):
    print(f"User {name} registering...")
    event_data = {
        "user_id": u_id,
        "username": name,
        "email": mail,
        "timestamp": time.time()
    }
    r.publish("user_events", json.dumps(event_data))
    print(f"Published 'user:registered' for {name}")

if __name__ == "__main__":
    register_user("101", "alice", "alice@example.com")
    time.sleep(0.5)
    register_user("102", "bob", "bob@example.com")

Consumer: Reacting to an Event

Now, let's see how a Notification Service (consumer) could subscribe to the user_events channel and send a welcome email.

Run this code in a separate terminal after starting the producer.

import redis
import json
import time

r = redis.Redis(decode_responses=True)
p = r.pubsub()

def send_welcome_email(user_data):
    print(f"Sending email to {user_data['email']}")
    time.sleep(0.3) # Simulate sending
    print(f"Email sent to {user_data['username']}.")

if __name__ == "__main__":
    print("Notification Service started.")
    print("Subscribing to 'user_events'...")
    p.subscribe('user_events')
    for msg in p.listen():
        if msg['type'] == 'message':
            try:
                data = json.loads(msg['data'])
                print(f"Received: {data['username']}")
                send_welcome_email(data)
            except json.JSONDecodeError:
                print(f"Error decoding: {msg['data']}")
        time.sleep(0.01)

Notifications & Real-time Updates

Beyond microservice communication, Redis Pub/Sub in an EDA is excellent for real-time notifications.

Chat applications: Send new messages instantly to all participants.
Live dashboards: Update metrics or status for users in real time.
Alerts: Notify administrators of critical system events.

The immediate nature of Pub/Sub makes these scenarios simple to implement.

Quick Check: EDA with Redis

Which of the following best describes the role of Redis Pub/Sub in an Event-Driven Architecture?

Recap: EDA & Redis Pub/Sub

You've learned how Redis Pub/Sub is a powerful tool for building Event-Driven Architectures!

EDA relies on events, producers, and consumers for communication.
Redis Pub/Sub acts as an efficient event bus.
It enables loose coupling and scalability for microservices.
It's perfect for real-time notifications and inter-service communication.

This pattern makes your applications more resilient and flexible. Well done!

Häufig gestellte Fragen

Ist die Lektion „Ereignisgesteuerte Architektur“ kostenlos?

Ja — der vollständige Text von „Ereignisgesteuerte Architektur“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Redis Caching & Messaging (Pub/Sub, Streams)-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Redis Caching & Messaging (Pub/Sub, Streams)-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Ereignisgesteuerte Architektur“?

Erkunden Sie, wie Redis Pub/Sub die Kommunikation und Benachrichtigungen in ereignisgesteuerten Microservices unterstützen kann. Du übst Redis Caching & Messaging (Pub/Sub, Streams) mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Redis Caching & Messaging (Pub/Sub, Streams) zu starten?

Keine Vorkenntnisse erforderlich. Redis Caching & Messaging (Pub/Sub, Streams) auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Ereignisgesteuerte Architektur“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Redis Caching & Messaging (Pub/Sub, Streams)-Lektion Code schreiben und ausführen?

Ja. Jede Redis Caching & Messaging (Pub/Sub, Streams)-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Redis Caching & Messaging (Pub/Sub, Streams)