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

Arsitektur Berbasis Peristiwa

Jelajahi cara Redis Pub/Sub dapat memfasilitasi komunikasi dan notifikasi layanan mikro berbasis peristiwa.

Arsitektur Berbasis Peristiwa adalah pelajaran Redis Caching & Messaging (Pub/Sub, Streams) gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Redis Caching & Messaging (Pub/Sub, Streams), dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Redis Caching & Messaging (Pub/Sub, Streams) mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Arsitektur Berbasis Peristiwa” gratis?

Ya — teks lengkap “Arsitektur Berbasis Peristiwa” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Redis Caching & Messaging (Pub/Sub, Streams), upgrade ke CoddyKit PRO. Kursus Redis Caching & Messaging (Pub/Sub, Streams) mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Arsitektur Berbasis Peristiwa”?

Jelajahi cara Redis Pub/Sub dapat memfasilitasi komunikasi dan notifikasi layanan mikro berbasis peristiwa. Kamu berlatih Redis Caching & Messaging (Pub/Sub, Streams) dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Redis Caching & Messaging (Pub/Sub, Streams)?

Tidak diperlukan pengalaman sebelumnya. Redis Caching & Messaging (Pub/Sub, Streams) di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Arsitektur Berbasis Peristiwa” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Redis Caching & Messaging (Pub/Sub, Streams) ini?

Ya. Setiap pelajaran Redis Caching & Messaging (Pub/Sub, Streams) menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Redis Caching & Messaging (Pub/Sub, Streams)