Microservices & Apache Kafka

Available On-Demand

Application architecture is shifting from monolithic enterprise systems to flexible, scalable, event-driven approaches. Welcome to the microservices era.

What are microservices, and how do they work?

Microservices separate monolithic systems into a collection of independent, self-containing services that allow easier deployment, testing, and maintenance.

Pros and cons of microservices architecture:

Microservices have numerous benefits: being far faster and easier to build and maintain apps, autonomous teams, and avoiding the bottlenecks that come with monolithic architectures. Most importantly, microservices offer simplified, agile, flexible, and scalable development that keeps up with modern business requirements.

The problem with microservice architectures is the need for increased communication between distributed instances, and the need for microservices orchestration, new failover requirements, and resilient design patterns.

How will you, and your organization, build modern, scalable applications on microservices, yet not obscure what’s possible with a principally different and observable data flow?

Not only is a new way of thinking needed, but also a new set of tools and infrastructure.

Why Kafka is used in Microservices:

Apache Kafka® is the most popular tool for microservices because it solves many of the issues of microservices orchestration while enabling attributes that microservices aim to achieve, such as scalability, efficiency, and speed. It also facilitates inter-service communication while preserving ultra-low latency and fault tolerance.

This three-part online talk series introduces key concepts, use cases, and best practices for getting started with microservices.

Register now to learn:

• Fundamentals of microservices architecture
• Why Kafka is needed for microservices communication
• How to build event-driven services using Kafka
• Why Kafka became the de facto standard and backbone for microservice architectures

This series is the definitive guide for all things microservices and includes a thorough understanding of the design principles behind microservices, the problems that arise as you grow and how you can leverage a streaming platform as the foundation for building your modern application architectures.

Microservices, it turns out, need a backbone. Kafka can be just that.

Part 1: The Data Dichotomy: Rethinking the Way We Treat Data and Services

Services come with a problem: they’re not well suited to sharing data. This talk examines the underlying dichotomy we all face as we piece such systems together. One that is not well served today. The solution lies in blending the old with the new and Apache Kafka plays a central role.

Part 2: Building Event-Driven Services with Apache Kafka

Should you use REST to communicate between microservices? Is it better to use a richer, brokered protocol? This practical talk digs into the benefits of event-driven systems for microservices, how it works, and how we use a distributed log to create a central, persistent narrative.

Part 3: Putting the Micro into Microservices with Stateful Stream Processing

How small can a microservice be? This talk looks at how Kafka works in microservices, what stateful stream processing is, and how it’s used to build truly autonomous, often minuscule services. With the distributed guarantees of Exactly Once Processing, and simplified scalability, Event-Driven Services supported by Apache Kafka become reliable, fast, and nimble, blurring the line between business system and a big data pipeline.