monolithic | monolithic lancache service capable of caching all CDNs | REST library

You will have to define a ServiceEntry so Istio will be aware of your external service. That ServiceEntry can be used as a destination in a VirtualService. https://istio.io/latest/docs/reference/config/networking/virtual-service/#Destination

First of all, you need to check if it makes sense to have Product and Ingredient in a separated project. It seems they belong to the same domain.

Talking about a microservices approach you should not declare Ingredient entity as dependency of Product.

"APEX" is a set of stored procedures that is installed in the database. "ORDS" is a Java application that is installed on Tomcat and talks to APEX in the database. I wrote a guide on this a couple of years ago. Doesn't sound like you'd need the high availability or header authentication parts, but the initial setup is largely the same. It might add to your understanding, anyway. See here:

• https://pmdba.files.wordpress.com/2019/09/ha-oracle-ords-apex-with-http-header-authentication.pdf

I think you biggest bottleneck (it very well could be a code issue too but this may be low hanging fruit, and in general best to design for scale) is trying to run everything on the same server (Unless I'm not understanding correctly but that's what it sounds like

Everything is sat on a single contained node/nuxt application

With that assumption each of your applications should be placed on their own server so, as an example

Note: If you are not familiar with managing these services then I would probably look for a managed type solution

1. Redis server for caching X 1
2. Mongo server for DB X 1

DB and Redis are usually very performant so a single instance should be fine to start, not to say a cluster would not be needed but right now you should be ok

Now for the application stack you are going to want to break out each app to its own server, what this means is

1. Game (express)
2. Socket.IO
3. Rest API?

Should all be separate application, each capable of using the full CPU, without having to compete with other processes.

In you post you mentioned things started to slow down and lag, this could simply be the eventloop is backed up, Node ( single threaded ) will process in order of the request so if that keeps filling up, well things will take longer to process.

Now, you mentioned how you would do this, and well that is a big question and depending on who you ask you will get different answers, and the 'right' solution is going to depend on how much you want to manage and how comfortable you are with each technology. For example, you mentioned containers.. Containers are great! but if you are not familiar with Docker and Kuberneties and the concepts in general it can be a challenge and if you are a one man shop, well thats even more work..

So, as I'm sure cost is a factor because, well it always is but luckily its not too expensive to start..

Personally I use multiple servers and services from AWS, Linode and Digital Ocean (100.00 free credit), I like Digital Ocean (even though some dont, I have not had issues with them so I will talk in terms of using them)

Now getting started, you can always spin up multiple 'Droplets' and use PM2 to take full advantage of each CPU for each application, this works but you still need to add a load balancer etc, and to scale horizontally you need to provision new servers, configure and add them to the clusters, again this will work but its more work.

Digital Ocean does offer a service call 'Apps' that is basically a CAAS offering, that allows you to deploy from GIT to a container, letting you scale out horizontally very quickly, I use this service for my socket.io services.. When I know I'm going to have a heavy load, I just add a few more 'apps' to my socket server and scale from 2 to 6 servers in a few min, then when I'm not I scale it down..

So my TLDR is, break everything apart, you don't want to have apps competing for resources

*** Edit ***

Just to add to this, as @kissu mentioned, you can for sure use Heroku, very similar to DO Apps however (my personal experience here) they can be a bit more expensive but with auto scaling (DO Apps does not offer that). For me I know when I'll experience spikes so its easy for me to plan but with a game autoscaling may be something to look at or consider. In that case Heroku OR AWS may work better (AWS with Auto Scale groups with custom AMIs for your app)

Dependency Injection is the concept of passing depended on objects into the object itself. In this case passing the IRepository repository into the AnonymousLoginService means that AnonmyousLoginService is dependent upon IRepository. It has nothing to do with the parameters passed into the methods.

If you feel it is best to have the separation of concerns and instantiating new db models in the method to verify that it is valid, instead of accepting user input as a db model and passing it in. It is okay.

Having the Domain Layer in a separate application is not wrong at all. Especially if you don't want to have to create a new Domain Layer for every application built. The Domain Layer could be used this way to loosely couple the code and have one single Domain Layer for multiple applications. Assuming that method return types, method names, and method parameters don't change, a change to the Domain Layer should not break any project depending on it.

As far as having the api know about both types of models (db and api models) sounds a lot better than having the Domain Layer know about both types of models. The Domain Layer would probably be better served to only know about Domain Models, then every application that uses the Domain Layer could also have access to the Domain Models. Instead of having the Domain Layer understand models from multiple projects, the only thing to consider is how secure the domain models should be? Maybe have set of dummy domain models (public facing db models) and a set of private db models (actual db models) and the Domain Layer gives access to the dummy models and then from there instantiates the actual db models. Ensuring that the actual logic and code is encapsulated.

You are correct, clustering is a way of scaling out to handle really high request loads and store tons of data.

It really doesn't quite sound like you need to bother with a cluster. I'd quite be very surprised if a standalone Redis setup would be your bottleneck before having several tens of thousands of simultaneous players.

If you are unsure, you can probably mock some simulated load and see what it can handle. My guess is that you are better off focusing on other complexities of your game until you start reaching quite serious usage. Which is a good problem to have. :)

You might however want to consider having one or two replica instances, which is a different thing.

Secondly, regardless of cluster or not, why do you want to use snap-shots (SAVE or BGSAVE) to persist your scoreboard?

If you want to have individual snapshots per game, and its only a few keys per game, why don't you just have your application read and persist those keys when needed to a traditional db? You can for example use MULTI, DUMP and RESTORE to achieve something that is very similar to snapshotting, but on the specific keys you want.

It doesn't sound like multiple databases is warranted for this.

Multiple databases on clustered Redis is only supported in the Enterprise version, so not on ElastiCache. But the above mentioned approach should work just fine.

If you complete the big-O analysis you will see that both options reduce to O(n). They have identical complexity!

They probably don't have the same performance, but complexity and complexity analysis (and Big-O notation) are not for measuring or predicting performance. Indeed, an O(n) algorithm may perform better than an O(1) algorithm for small enough values of n.

Does Java have some optimization in terms of execution or compiling?

Yes. The JIT compiler does a lot of optimization (at runtime). However, we can't predict if Options 1 and 2 will have equivalent performance.

Should I be concerned with this kind of performance question?

Yes and no.

It depends on whether / how much performance matters for your project. For many projects¹, application performance is unimportant compared with other things; e.g. meeting all of the functional requirements, computing the correct answer all of the time, not crashing, not losing updates, etc.

And when performance is a concern, it is not necessarily the case that >this< snippet of code (out of the hundreds, thousands, millions of lines in the codebase) is worth optimizing. Not all code is equal. If this code is only executed occasionally, then optimizing it is likely to have a minimal effect on overall performance.

The standard mantra is to avoid premature optimization. Wait until you have the code working. THEN create a benchmark for measuring the application's performance doing actual work. THEN profile the application running the benchmark to find out which parts of the code are performance hotspots ... and focus your optimization efforts on the hotspots.

^{1 - The point is performance must be considered in the context of all the other requirements and constraints on the project. And if you spend too much time on performance too early, you are liable to miss deadlines, etcetera. Not to mention wasting effort on optimizing the wrong code.}

Create four .NET 5.0 WebApis, you can run them both on Linux and Windows. And when it comes to authentication it's really easy to implement basic JWT with literally six lines in each service assuming that you're using Open Id Connect.

I haven't tested with the DeepSpeech library compilation but the following bazel flag can disable the RUY to enable the other GEMM libraries for the TensorFlow Lite library compilation through the bazel tool.