Arquitetura orientada a eventos
Explore como a publicação e assinatura do Redis pode facilitar a comunicação e o envio de notificações entre microsserviços orientados a eventos.
Arquitetura orientada a eventos é uma aula grátis de Redis Caching & Messaging (Pub/Sub, Streams) no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Redis Caching & Messaging (Pub/Sub, Streams), e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Redis Caching & Messaging (Pub/Sub, Streams) inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
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!
Perguntas Frequentes
A aula “Arquitetura orientada a eventos” é grátis?
Sim — o texto completo de “Arquitetura orientada a eventos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Redis Caching & Messaging (Pub/Sub, Streams), atualize para CoddyKit PRO. O curso de Redis Caching & Messaging (Pub/Sub, Streams) inclui 4 aulas no total.
O que vou aprender em “Arquitetura orientada a eventos”?
Explore como a publicação e assinatura do Redis pode facilitar a comunicação e o envio de notificações entre microsserviços orientados a eventos. Você pratica Redis Caching & Messaging (Pub/Sub, Streams) com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Redis Caching & Messaging (Pub/Sub, Streams)?
Nenhuma experiência prévia é necessária. Redis Caching & Messaging (Pub/Sub, Streams) no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Arquitetura orientada a eventos”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Redis Caching & Messaging (Pub/Sub, Streams)?
Sim. Cada aula de Redis Caching & Messaging (Pub/Sub, Streams) inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Assinaturas com correspondência de padrões
- Projeto de um bate-papo em tempo real
- Arquitetura orientada a eventos
- Rastreamento de presença e status online