The tour of Akka cluster continues! In the previous article, we learned how to use techniques for making a reactive payment processor resilient to failure using Akka Cluster. Here, Manuel Bernhardt takes a closer look at how to scale out the reactive payment processor application using cluster sharding.
Do you want to build a more stable system that’s able to cope with individual node crashes? Join Manuel Bernhardt in this tutorial as he shows us techniques for making a reactive payment processor resilient to failure using Akka Cluster.
How can we make building distributed systems easier? In this article, Manuel Bernhardt explores one useful tool in the Akka toolbox: Akka Cluster. Today, we’re taking a closer look at one module, Akka Distributed Data, and how it can be used to build an example reactive payment processor.
The fundamental building block of Akka actor systems is an actor. In a way, actors are analogous to Lego or Minecraft blocks: With the simple building blocks of Lego and Minecraft, it is possible to craft magnificent structures. In this article, Hugh McKee, developer advocate at Lightbend tells you everything you need to know about cluster aware actors.
While there is a wealth of documentation around Akka, based on Lightbend’s real-world experience with users and customers over the last few years, they realized that there is a need for tutorial-style tips that focuses on different aspects of Akka. In this post, Hugh McKee focuses on Akka clustering vs. Akka remoting.
Big Data is changing. Buzzwords such as Hadoop, Storm, Pig and Hive are not the darlings of the industry anymore —they are being replaced by a powerful duo: Fast Data and SMACK. Such a fast change in such a (relatively) young ecosystem begs the following question: What is wrong with the current approach? What is the difference between Fast and Big Data? And what is SMACK?
Last year, Akka won the JAX Innovation Award for Most Innovative Open Source Tech—we’re still very proud of this recognition!—and one thing I can say is that winning the award did not make us pause or slow down. A lot is happening in and around Akka as we will see in this whirlwind tour through the ecosystem.
Choosing Akka as a tool is often – if not always – driven by the need for good performance. Surely, the actor model itself is appealing as a means for organizing and reasoning about code, but this isn’t in itself a good reason enough to use the Akka toolkit.
In this article, Vaughn Vernon, author of “Implementing Domain- Driven Design”, “Reactive Messaging Patterns with the Actor Model”, and “Domain-Driven Design Distilled”, will teach you a first approach method to designing microservices, giving you a workable foundation to build on. He will introduce you to reactive software development and summarize how you can use Scala and Akka as a go-to toolkit for developing reactive microservices.
Reactive programming is gaining momentum but people are still reluctant to jump on the bandwagon. To help you overcome the fear of the unknown, we decided to ask Scala, Lagom, Spark, Akka and Play experts to explain how these elements coexist and work together to create a reactive universe. This JAX Magazine issue is packed with goodies — it’s our treat!
Admittedly I’ve seen this one in use only one time, but it was one time too many. For some reason I keep seeing clients come up with this during design discussions and reviews, therefore it makes it into the list of Akka anti-patterns.
When working with actors, you should always respect the following guideline: Do not, under any circumstances, close over mutable state. Since the actor model is a model, not a framework, it is up to you to make sure that you do, indeed, follow this guideline. Akka will not magically warn you if you misstep; however, your application will begin to act weirdly. In this article, Manuel Bernhardt explores a few ways in which you could misstep.
One of the fundamental ideas built into Akka is the one of failure handling through parental supervision. In other words, this means agencing actors in such a way that parent actors that depend upon the correct execution of a child to perform their work are also responsible for deciding what to do when one child actor crashes.
When I work with clients on designing actor systems there are a few anti-patterns that seem to make it into initial, non-reviewed designs no matter what. In this series of short articles I would like to cover a few of those.