Exploring Reactive Integrations with Akka Streams, Alpakka and Kafka


Exploring Reactive Integrations with Akka Streams, Alpakka and Kafka

With Konrad Malawski

reactive akka akka-streams

Audience: Architects
Technical level: Introductory

Since its stable release in 2016, Akka Streams is quickly becoming the de facto standard integration layer between various Streaming systems and products. Enterprises like PayPal, Intel, Samsung and Norwegian Cruise Lines see this is a game changer in terms of designing Reactive streaming applications by connecting pipelines of back-pressured asynchronous processing stages.

This comes from the Reactive Streams initiative in part, which has been long led by Lightbend and others, allowing multiple streaming libraries to inter-operate between each other in a performant and resilient fashion, providing back-pressure all the way. But perhaps even more so thanks to the various integration drivers that have sprung up in the community and the Akka team—including drivers for Apache Kafka, Apache Cassandra, Streaming HTTP, Websockets and much more.

In this webinar for JVM Architects, Konrad Malawski explores the what and why of Reactive integrations, with examples featuring technologies like Akka Streams, Apache Kafka, and Alpakka, a new community project for building Streaming connectors that seeks to “back-pressurize” traditional Apache Camel endpoints.

  • An overview of Reactive Streams and what it will look like in JDK 9, and the Akka Streams API implementation for Java and Scala.
  • Introduction to Alpakka, a modern, Reactive version of Apache Camel, and its growing community of Streams connectors (e.g. Akka Streams Kafka, MQTT, AMQP, Streaming HTTP/TCP/FileIO and more).
  • How Akka Streams and Akka HTTP work with Websockets, HTTP and TCP, with examples in both in Java and Scala.


Related Videos

Building Streaming And Fast Data Applications With Spark Mesos Akka Cassandra And Kafka


fast-data akka mesos spark

Building Streaming And Fast Data Applications With Spark Mesos Akka Cassandra And Kafka

with Sean Glover

It’s become clear to many business that the ability to extract real-time actionable insights from data is not only a source of competitive advantage, but also a way to defend their existing business models from disruption. So while legacy models such as nightly batch jobs aren’t disappearing, an era of fast, streaming data (aka “Fast Data”) is upon us, and represents the state of the art for gaining real-time perishable insights that can then be used to serve existing customers better, acquiring new markets and keep the competition at bay.

That said, distributed, Fast Data architectures are much harder to build, and carry their own set of challenges. Enterprises looking to move quickly are presented with a growing ecosystem of technologies, which often delays fast decisions and provides its own set of risks:

  • With so many choices, what tools should you use?
  • How do you avoid making rookie mistakes?
  • e best patterns and practices for streaming applications?

In this webinar with Sean Glover, Senior Consultant at Lightbend and industry veteran, we examine the rise of streaming systems built around Spark, Mesos, Akka, Cassandra and Kafka, their role in handling endless streams of data to gain real-time insights. Sean then reviews how the Lightbend Fast Data Platform (FDP) brings them together in a comprehensive, easy to use, integrated platform, which includes installation, integration, and monitoring tools tuned for various deployment scenarios, plus sample applications.

Using the Actor Model with Domain-Driven Design (DDD) in Reactive Systems



Using the Actor Model with Domain-Driven Design (DDD) in Reactive Systems

with Vaughn Vernon

Is the Actor Model just a new "shiny object" for developers to chase after, a fad soon to be abandoned? In fact, the Actor Model was first designed in 1973–over 20 years before brands like Yahoo! and Hotmail first arrived at the burgeoning internet. Created to address the long-term direction of computing and software development, it is almost as old as the formal definition of object-oriented programming.

Fast forward to 2017, where we are faced with an online and mobile world that continues to grow exponentially, and a third wave of IoT aims to add hundreds of billions of connected devices to our lives.

To manage today’s demanding needs and to prepare for the coming wave, enterprises like Intel, Samsung, Walmart, PayPal, Hootsuite, and Norwegian Cruise Lines are embracing distributed, Reactive systems deployed on hybrid cloud infrastructures. Central to these systems and applications is the Actor Model, which is seeing “renewed interest as cloud concurrency challenges grow,” according to Forrester Research.

In this webinar, special guest Vaughn Vernon explains why actors are so vital to the future of software development. You will learn:

  • Why actors are so exceptionally well-suited for use with Domain-Driven Design, speaking the Ubiquitous Language of your core business domain.
  • How actors are designed to gracefully handle failure, maintaining system resilience and responsiveness to users no matter what’s happening.
  • How actors help you reactively scale your systems meet concurrency demands, elastically growing up and out to handle peak load, and shrinking when not minimizing your infrastructure and hardware footprint.

The Basics Of Reactive System Design For Traditional Java Enterprises


reactive java

The Basics Of Reactive System Design For Traditional Java Enterprises

with Sean Walsh and Duncan DeVore

Like most things in life, in software there exists an Old and a New way of doing things. The growth of computing power, increase in the sheer number of users, cheaper and more available hardware, and the explosive IoT market mandates that we build our systems using modern methods that diverge from past.

This modern way is called “Reactive”, which was first co-authored by Lightbend in 2013 with the Reactive Manifesto and now has over 15,000 signatories. With 2017 nearly upon us, we now see the market widely embracing Reactive in response to the many Architects, Developers and DevOps practitioners failing to meet tough new demands on their systems using last year’s technologies and monolithic designs.

Yet with this popularity, the term Reactive is being overloaded and confused. Some believe that asynchronous messaging alone is good enough. As we will see, this is only part of the puzzle.

In this webinar aimed at Architects and Developers working with more traditional Java environments, Lightbend’s Sean Walsh and Duncan DeVore take us on a journey that goes beyond just asynchronous programming and into the very basics of designing Reactive systems as a whole.

We will review:

  • Why simply implementing asynchronous messaging is only part of the puzzle, and what it means to build entire systems as a whole based on the principles of Reactive system design: message-driven, resilient, elastic and responsive.
  • How to avoid repeatedly building monoliths by embracing tried-and-true concepts of Domain Driven Design (DDD), Command Query Responsibility Segregation (CQRS) and Event Sourcing.
  • How the Actor Model with Akka makes concurrency a breeze and harnesses clustered computing capabilities to divide and conquer work.
  • How to design systems that can self-heal, self-scale, both up and down and truly provide the most real time and responsive experience for your customers, clients and partners while being a joy to program and maintain.

Distributed Systems Done Right: Why Java Enterprises Are Embracing The Actor Model


akka java

Distributed Systems Done Right: Why Java Enterprises Are Embracing The Actor Model

with Hugh McKee

Most likely, your job is heavily focused on helping your organization modernize for the digital era. As the days of purely Object-Oriented Programming and related frameworks come to a close, enterprises migrating to distributed, cloud infrastructures are embracing a different approach: the Actor Model.

When it comes to distributed computing, the Actor Model is the great-grandparent of it all.

Created by Carl Hewitt in 1973, Forrester Research notes, “the Actor model is seeing renewed interest as cloud concurrency challenges grow.”

Yet even if you understand the Actor Model and used some of the toolkits for it (e.g. Akka and Erlang), how do you easily explain the concept to your team, colleagues and managers? Where do you start?

In this webinar, Hugh McKee, Global Solutions Architect at Lightbend, shows you how Actors behave and interact as humans do when it comes to communicating, and how these similar behavioral patterns provide basic intuition when designing Reactive systems. Actors allow your teams to focus on an application’s business logic rather than on low-level protocols, accelerating time-to-market while keeping your infrastructure costs low.

Our goal is twofold: provide you with a comprehensive review of the Actor Model, and give you the resources you need to help others learn why enterprises like Walmart, Intel, Samsung, IBM, Norwegian Cruise Lines and HSBC are committed production users of Akka, the JVM-based toolkit built on the Actor Model.

In this webinar, you’ll learn:

  • Why actor-based systems are one of the foundational technologies for creating microservices architecture (MSA)
  • How Actors delegate work by creating other Actors in a supervisor-to-worker relationship
  • How Actors manage requests and scale horizontally in large systems
  • The difference between traditional systems and actor-based systems
  • How an Actor system forms clusters when the flow of work exceeds a system’s capacity to process it
  • Why failure detection and failure recovery is an architectural feature of Actor systems
  • An example of using Actors to build an Internet of Things (IoT) application

Lessons Learned From PayPal: Back Pressure With Akka Streams And Kafka


akka-streams reactive-streams

Lessons Learned From PayPal: Back Pressure With Akka Streams And Kafka

with Akara Sucharitakul

Audience: Architects, Management Technical level: Intermediate

Akka Streams and its amazing handling of streaming with back-pressure should be no surprise to anyone. But it takes a couple of use cases to really see it in action - especially in use cases where the amount of work continues to increase as you’re processing it. This is where back-pressure really shines.

In this talk for Architects and Dev Managers by Akara Sucharitakul, Principal MTS for Global Platform Frameworks at PayPal, Inc., we look at how back-pressure based on Akka Streams and Kafka is being used at PayPal to handle very bursty workloads.

In addition, Akara will also share experiences in creating a platform based on Akka and Akka Streams that currently processes over 1 billion transactions per day (on just 8 VMs), with the aim of helping teams adopt these technologies. In this webinar, you will:

  • Start with a sample web crawler use case to examine what happens when each processing pass expands to a larger and larger workload to process.
  • Review how we use the buffering capabilities in Kafka and the back-pressure with asynchronous processing in Akka Streams to handle such bursts.
  • Look at lessons learned, plus some constructive “rants” about the architectural components, the maturity, or immaturity you’ll expect, and tidbits and open source goodies like memory-mapped stream buffers that can be helpful in other Akka Streams and/or Kafka use cases.