Event Driven Architecture (بالعربي)

Explore how applications communicate in an event-driven architecture, covering data integration, internal and external communication, and the use of request-response and notification microservices.

Explore integration issues in event-driven architecture, comparing synchronous request-response models with asynchronous messaging across microservices and cloud-native distributed systems. Learn about notification services and cross-language flexibility.

Assess how event-driven architecture ensures secure, synchronized address data across healthcare, accounting, and recruiting systems, evaluating messaging options, file transfer, and database replication, and exposes endpoints via API.

Explore how an e-commerce system with 10 million users manages concurrent requests through horizontal scaling, resource buffering, and a hybrid event-driven messaging approach versus the request-response model.

Explore how health care workflows use event-driven architecture to enable loosely coupled messaging and request-response models, supporting bookings, payments, pre-checks, and notifications through robust queuing and data buffering.

Explore how the messaging system enables event driven architecture, with producers, consumers, and message headers and bodies transported through topics or brokers with middleware like Kafka, RabbitMQ, ActiveMQ, or SQS.

Explore how messaging systems enable language agnostic, loosely coupled architectures with high throughput, throttling, and store and forward reliability for buffering and event streams.

Delve into the trade-offs between synchronous and asynchronous approaches in event-driven messaging. Weigh deterministic request-response models against send-and-forget patterns to design resilient, traceable systems.

Explore event driven messaging concepts, including command, event, and notification messages in a microservice architecture. See how Kafka coordinates flight booking workflows with platform notifications and observability.

Explore event-driven architecture concepts, including interpretation of commands and events, async decoupling, producers, consumers, middleware, and notification services using Kafka in a booking workflow.

Explore how document messages drive event driven architecture, connecting data sources, the order service, databases, and data science workflows with etl, cdc, and reporting.

Explore ETL and ELT workflows, moving data from application databases to a data warehouse and analytics system, including CDC, batch dumps to S3, and cost-aware cloud storage considerations.

Define events as immutable messages that announce what happened, distinguishing commands from events and showing how events drive business workflows through loosely coupled messaging.

Explore how command, document, and event messaging compare within event driven architecture, covering sync and async api patterns, request and response versus fire-and-forget, and brokered one-to-one and one-to-many communications.

Reframe the booking flow as a notification driven architecture, using an orchestrator and message broker to emit booking confirmed events, email or sms, and enforce completion after notification is sent.

Explore how messages become events in an event driven architecture, with json payloads, event id, type, timestamp, and source, and how keys, correlation, and locality influence ordering and partitions.

Share feature toggles across systems with edge validation and header context, enabling or disabling booleans, and accumulator events through channels to subscribers.

Explore event driven messaging and architecture, including the observer design pattern, request-reply, and fire-and-forget. See how brokers and queues enable loose coupling and topic-based broadcasting in distributed systems.

Understand the core components of event driven architecture, including messages and events, brokers and channels, producers and consumers, and the observer pattern.

Analyze how channels govern sender and receiver communication, defining broker behavior and point-to-point or publish-subscribe models, with producers, consumers, queues or topics and infrastructure as code.

Explore rabbitmq architecture as a message broker, including producers, consumers, exchanges, and queues, with direct and topic exchanges, routing patterns, publish/subscribe messaging, plus admin panel and monitoring.

Explore how to set up and administer RabbitMQ with Docker and Docker Compose, configure the admin panel and UI, and manage exchanges, queues, channels, and clustering for scalable messaging.

Explore queue versus topic in an event-driven microservice order system, detailing message sequencing, partitions, and Kafka-based guarantees for throughput, offset tracking, and reliable consumption.

Explore data safety in event-driven systems using a messaging broker, producer, and consumer with durable queues and acknowledgments. Learn how retention policies and persistence mitigate failures and ensure reliable delivery.

Explore RabbitMQ producer and consumer patterns, including queues, quorum, replication, and message persistence options. Practice publish and read workflows with acknowledgement modes and message IDs.

Examine RabbitMQ and mass transit abstractions, focusing on producer and consumer channels, TCP and HTTP layers, and resilient clustering for active-active and active-passive architectures.

Explore the trade-offs of cloud service risks in event-driven architecture, balancing on-prem systems with cloud messaging options like Amazon MQ and HTTP-based queues, weighing pros and cons.

Explore producer delivery semantics in event driven architecture, focusing on reliable messaging with RabbitMQ, acknowledgements, confirmations, and handling duplicates, retries, and failures in distributed systems.

Explore how consumer delivery semantics govern message acknowledgement, redelivery, and producer confirmation in RabbitMQ. Contrast competing consumers and consumer groups in RabbitMQ and Kafka, with auto, manual, and negative acknowledgement.

Competing consumers subscribe to a RabbitMQ broker, where producers publish events from the order service to an event queue, triggering SMS and email notifications to subscribers, with acknowledgement ensuring processing.

Examine delivery semantics and confirmation in event driven architectures, including producer–consumer patterns and queue fan-out across systems. Evaluate trade-offs in throughput, isolation, and scalability for messaging and API request–response models.

Increase RabbitMQ throughput by optimizing fifo delivery, prefetch settings, and round-robin rebalancing across single or multi-threaded consumers within a channel-based architecture.

Explore how event driven architecture uses fan-out messaging, exchanges with RabbitMQ, and prefetch to boost parallelism, throughput, and reliable delivery across multiple queues and consumers.

Publish and consume messages with RabbitMQ using a simple Java producer and consumer. Configure AMQP connections, exchanges, queues, routing keys, and delivery acknowledgements for reliable event driven architecture.

Explore data safety in distributed, event-driven architectures through RabbitMQ clustering, replication, and quorum strategies, comparing raft and paxos consensus to prevent single points of failure.

Explore quorum queues within a distributed event-driven architecture, focusing on leader election, data replication, and failure handling using Rabbit MQ concepts like clusters, producers, and followers.

Learn to implement a Go-based producer and consumer for RabbitMQ, using channels for async publish to an exchange and queue with JSON messages.

Apply RabbitMQ message priorities within event driven architecture, using Zmax priority, classic queues, high and critical queues, and TTL, durability, exchange names, and prefetch size.

Explore an event driven architecture case study for an online retailer, detailing legacy modernization with a unified message translator, channel adapters, and API-driven data flows.

Explore how Zalavdo case study part 2 demonstrates event driven architecture through order processing, inventory validation, and async pipelines, with content-based routing, aggregators, and exception handling.

Design a notification system with RabbitMQ, using high and normal priority queues for SMS, email, and VIP messages, managed by producers and consumers.

Explore how change data capture enables real-time data synchronization within an event-driven architecture using CDC agents, Kafka Connect, and data virtualization to support reporting and BI from multiple sources.

Explore event-driven architectures enabling real-time data flows from operational stores to analytical queries using CDC and transformations. Leverage RabbitMQ, AMQP, and notification hubs for publish–subscribe messaging across services.

Learn how event driven architecture leverages MQTT for IoT, using brokers and topic-based publish–subscribe with hierarchical topics, wildcards, and quality of service levels for reliable messaging.

Explore broker technologies such as mqtt, mosquito, http, and mqtt over WebSocket, and learn no-code integration with node-red for event-driven applications.

Explore how event streaming powers event driven architecture for scalable cloud native microservices. Learn producer and consumer roles and see Apache Kafka, Flink, and Spark in action.

Explore the Kafka architecture as a distributed streaming platform with brokers, topics, and partitions, supporting producer and consumer APIs, ZooKeeper, and connectors for high availability and scalability.

Explore high availability, durability, and scalability in event-driven architectures, comparing Kafka, Kinesis, and RabbitMQ for handling millions of events, with serverless options and Kubernetes tradeoffs.

Explore Kafka applications for high-throughput event streaming, change data capture with Kafka Connect and Debezium, and plug-and-play data pipelines across legacy and modern systems.

Explore how to set up a Kafka producer to send messages in an event-driven architecture, using Kafka Streams and functional programming operators to build a data pipeline.

Explore Kafka producer internals and how batching and zero-copy flush enable high throughput. Compare Kafka and RabbitMQ concepts like topics, partitions, and backpressure in event streaming.

Compare Kafka and RabbitMQ architectures, detailing producers and consumers, push/pull models, offsets and last committed offsets, batch processing, acknowledgments, partitions, consumer groups, rebalancing, replication, durability, and retention.

Explore Apache Kafka as an engine with dockerized setup, Kafka UI, topics and producers and consumers, plus Kafka Streams and KTable concepts for building event-driven architectures.

Explore how Kafka uses in-sync replicas, leader elections, and acknowledgments to achieve resiliency and durability, with topic partitions, brokers, and replication for reliable streaming.

Explore retry strategies and failure handling in event driven architectures, including idempotency, poison pills, and dead letter queues in RabbitMQ and Kafka.

Learn how the outbox pattern mitigates dual-write challenges in event-driven architectures by persisting events in a database table and asynchronously publishing them to Kafka.

Show the outbox pattern in a booking service, persisting bookings and publishing Kafka events for email and notifications via a scheduler processing pending outbox records.

Compare Lambda and Kappa event streaming architectures, highlighting how batch and speed layers enable real-time analysis with Apache Kafka, ETL, and stream processing in data pipelines.

Explore event-driven architecture by structuring a modular project with directory or package layouts, an api layer, and a core business logic wired to infrastructure and libraries.

Learn why and how event driven architecture enables streaming with Apache Kafka and RabbitMQ, detailing event payloads, headers, metadata, immutability, and traceability through correlation IDs and timestamps.

Learn how events are produced and timestamped, consumed by end users and data services, and tracked with correlation IDs, with Logstash, Kibana, and New Relic.

Define event schemas and data contracts to formalize producer and consumer communication in a Kafka system, using Avro or Protobuf for efficient binary serialization and JSON schema for readability.

Explore Avro in action within an event-driven architecture, illustrating Avro data files, schemas, and binary serialization for producer and consumer pipelines.

Learn how binary files produce schemas, XML and XML schema standards. Apply fail fast principles across producer and consumer layers, migrations with Flyway, and Kubernetes releases for data migration.

Learn how data transmission works in an event driven architecture with schema registries, producers and consumers, and versioned contracts to optimize latency and ensure backward compatibility.

Explore a real-time, event-driven logistics case study using Apache Kafka, showing how orders, dispatch, and shipments stream from IoT sensors to tracking systems.

Explore how event sourcing uses append-only, immutable logs to record state changes, enable auditing, and replay events via messaging systems like RabbitMQ or Kafka.

Explore the cqrs pattern in an event driven architecture, separating read and write models, using event sourcing and the outbox pattern for scalable, near real-time data synchronization via messaging systems.

Explore distributed transactions in event driven architecture using the two phase commit pattern, including coordinator and participant roles, prepare and commit steps, and rollback handling.

Learn how saga pattern enables reliable, event-driven workflows across services, handling authorization, shopping list, payment, cancellations, and rollback in cloud native applications.

Modernize legacy systems by migrating to a modern architecture with an exposed data boundary and APIs and event streams, using asynchronous processing and change data capture with Kafka.

Examine how legacy systems handle updates, deletions, and inserts across columns, and how data scanning and jobs manage recorded changes.