lagom | Reactive Microservices for the JVM | Microservice library

Lagom is an opinionated framework on top of Akka, especially around Cluster Sharding and Persistence (as well as a means to define HTTP interactions similarly to Play, and a defined approach to dependency injection). It included, in its ReadSideProcessor an opinionated way to project an event stream from persistence for CQRS.

Many recent advances in Akka are partially based on incorporating some learning from Lagom around being more opinionated. Projection brings something similar though more general (as it can project, e.g. events from Kafka) to the ReadSideProcessor to Akka; it may be noteworthy that Projection is largely the work of one of the core maintainers of Lagom.

I wouldn't really categorize Akka Platform as a PaaS, but more of an alternative pricing/consumption model for a subset of the "Lightbend Subscription" (Akka Platform is usage-based without as much of a consulting-type arrangement; the Subscription's pricing might fairly be described as "if you have to ask how much it costs, you probably can't afford it", but it does include some level of consulting engagement from a group that really knows the Akka/Lagom/Play stack). Otherwise the Akka Platform is Akka.

Akka Serverless's PaaS is Akka under the hood, but the Akka-ness is hidden (for better or for worse) behind a gRPC API. As in Lagom, you're defining domain entities' behavior and a framework layer is manifesting that as an Akka actor; Akka Serverless more strictly separates that manifestation than Lagom (it's quite possible and sometimes even useful in Lagom to strip away the Lagom veneer to expose more Akka), but that in turn allows the behavior to be defined in any language that can speak gRPC.

I can't speculate on what the future holds. Akka itself is pure open source (and not a small portion of its contributors aren't employed by Lightbend): so it's somewhat immune from whatever happens with Lightbend (the scope of the commercial add-ons has also decreased over the years, most notably with the multi-region persistence and the split-brain resolver being open-sourced). There are use cases for Akka that will probably never effectively be useful in Akka Serverless. As for Lagom, it's possible that it's achieved its goals and will be considered mature (joining various other microservice-first frameworks).

I personally would tend to use vanilla Akka: I'd consider the recommended Typed APIs (especially in Scala) to provide "just the right amount" of opinionation, albeit less than Lagom. Coming from a Scala background, the lack of DI is also appreciated. If you decide you want the commercial add-ons and are running in a public cloud on Kubernetes, then the Akka Platform is probably worth getting; for other deployments, the Subscription might be worth it.

You can return the modified Header and the Response as a Tuple:

You should set play.application.loader to the name of your loader class, rather than your persistent entity class:

Are you blocking in your calls? Eg, are you calling Thread.sleep? Or using some synchronous IO? If so, then what you're seeing is entirely expected.

Lagom is an asynchronous framework. All the IO and inter-service communication mechanisms it provides are non blocking. Its thread pools a tuned for non blocking. If you only using non blocking calls, you will see the thread pools behave with very low thread counts, and you won't find things going unresponsive.

But the moment you start blocking, all bets are off. Blocking requires one thread per request.

The default dispatcher that Akka uses is a fork join pool. It is designed for asynchronous use. If you block in a thread in its pool, it will start another thread to ensure other tasks can continue. So, that's why you see the thread pool grow. Don't block, and this won't happen.

The thread pool executor on the other hand uses a fixed number of threads. If you block on this, then you risk deadlocking the entire application. Don't block, and this won't happen.

It seems that the real cause for the exception was because I should have added logic for handling the event as follows: in helloEvents(), I needed to add logic similar to the following:

Your object CustomPostgresProfile extends PostgresProfile instead of CustomPostgresProfile. If you fix that, it works.

Writing to a file in a container is bad for two reasons: 1. Logs are available only within the container i.e.,would require to get into the container to see the logs 2. They are not available via kubectl log command 3. They are ephemeral in nature i.e., if container crashes, logs will disappear

Instead writing to STDOUT and STDERR is considered as best practise in a container environment. The logs written to STDOUT and STDERR are redirected by docker engine to a location in the node (/var/log/containers/). Moreover, these logs are also available via kubectl logs command.

Practically logs are not even preserved at even a node but are instead moved to a central logging system. You can read more about it here.

I think that you shouldn't have a different entity 'Transactions' because it is tightly coupled to the account entity, in fact, the transactions of an account is no more than the event log of this account. So I recommend persisting the balance with a unique transaction id and the id of the other account when it is a transfer transaction, and make the read processor to listen the events of the account changes to store them in the read model.

Doing this, a transfer is just a message between the two accounts that results in a modification of the balance that later will be persistent as part of the event log of each of them. This way seems more natural and you don't have to manage a sepparate aggregate root that, in addition, is tightly coupled to the account entities.

I was calling the wrong method. The openApiGenerators just list the generators which is what it was doing. To generate the output, you have to call the task created above openApiGenerate. Thanks @philonous for the answer.