Microservices Puns

We have about 800 microservices, some of them not touched for years, and never heard of by anyone still employed here - maybe written in a language e.g. Perl that nobody really knows well.

How is this kind of thing not a killer problem elsewhere? How do staff leaving not make their services hard to maintain?

I started coding in the early 2000s, back when SQL Server was king. A simple monolith dual back end server with replication setup could easily serve hundreds of thousands of users, while having full fault tolerance. There was no SSD, all running on slow HDDs.

Today the hardware and network speeds are farrrr better, SSD is there, more tools are available and servers are getting cheaper as well. DotNet Core on Linux is so resource efficient. Throw a PosgreSQL in there, it gets even better. Add a CDN touch, your site is blazing fast now!

However, most companies will always go for Kubernetees and Microservices as their back end setup. Citing it's the ’Norm’, ‘Embracing new Technologies’, ‘Future Proofing’ and etc. A lot of people are not a fan of it....Why? Cause it's so complicated for the average Dev! Everyone says it's easy, but the reality is, in PROD it gets so tangled up!

And these companies/organizations don't have visitors in the millions. Maybe a half a million visitors a month max, yet Kubernetees is always the go to.

Look at 'Stackoverflow.com', they are still on a Monolith setup, and using the WISC stack (That W is.. WINDOWS SERVER....., yes, old school.... WINDOWS SERVER). At the core of their setup, are TWO MSSQL databases in NYC with 384GB of RAM… serving 280MILLION Visitors a month.

But Kubernetees is Cheaper!! .....is it???
Add one senior back engineer it costs two times your monthly Cloud Prices.

But Kubernetees is Fault Tolerance!!
Yes… it is fault tolerance..  but not human error tolerance… which the biggest cause of down times.

But Kubernetees/Microservices is Scalable!!!
The only thing that is going to scale is your back end developer costs. Servers are cheaper!

OK... this is just a rant. Take it with a grain of salt. I’d like to hear your thoughts though! Go for it!

I was recently asked a question something like this, and did not have a good answer:

"Your build agents are ephemeral VMs or containers with no persistent storage. The git repository contains code for dozens or hundreds of microservices, and it would take a long time to build and test all of them. How to you drastically decrease iteration time to build and test when a developer makes a change to just one service, or even just a config file?"

I may have omitted some parts of the question, I don't remember 100%. At the time I felt like it was implied that docker was additionally involved in the "build", and that some type of caching may be involved, rather than just saying something like "each service should be in it's own repo/branch".

Things like NFS storage or some artifact store like artifactory occurred to me, but as I said, I didn't have a good and detailed answer.

Unfortunately at my job, build pipelines DO take a very long time and we aren't really using a microservice architecture .. so it hasn't been a problem I could solve recently.

Thanks !

I'm designing a system in which we have different microservices for a different part of the system. A common approach is to have a DDB database per microservice, but what are your thoughts about if Elasticsearch(Open search) is being synced to from some of the DDB databases? Should I have Elasticsearch instance (cluster) per microservice to claim my architecture nice and shiny, or is one instance (cluster) with many indexes is ok?

I was thinking to use an ElasticSearch cluster, where I'd have several indexes, indexes would serve as boundaries that separate the data which comes from various micro-services. I would like to underscore the fact that I plan to use ES only as a search engine, not as a system of record.

Here is my dilemma:

1. Should I allow each microservice to handle ES interactions directly (as caching and persistence)?

2. Or should I create a separate microservice (let's call it "search"), which would be the one that interacts with the ES cluster?

I am leaning towards 1. b/c since each microservice has to be autonomous in persistence, caching, it can also handle full-text searches too.

I am learning developing microservices from books and some udemy videos. And almost every tutorial the authors are using Azure Service Bus or/and Azure Message Queues.

In Spring boot there are lots of tools like Netflix Eureka, Hystrix, etc so that the developers are free to choose any service provider of their choice.

Can I develop microservices in .net using tools rather than a specific platform?

Currently, my company runs on a monolith of a grails application that we're running into many issues with that are going to be solved by splitting off some of the functionality into microservices. I'm the one putting together a plan for the architecture side on how that will look. In doing so, I'm trying to factor in as much as I can for the future, but need a little bit of guidance.

We're looking at writing the micro services in Node/Golang depending on need, and I'm planning on spinning them up in docker containers on EC2 instances for our environments. (We are currently 100% in AWS, using Elastic Beanstalk). My company has a business model that doesn't really require a lot of auto scaling, so I think going with ECS or Kubernetes may be a bit overkill. So my idea is to run everything for the services through docker-compose/swarm, that way I can set up zero downtime deployments.

We currently use Jenkins as our deployment tool through a few plugins since we only have the one app, I want to repurpose this into actual pipelines that deploys everything and continues to have all the code stored in one repository. The thing I'm worried about here is that part of the benefit of using microservices is you can just deploy those services that are changed and shorten your deployment times. How do people normally handle detecting which services actually have changes and need to be deployed if everything is stored in one repo?

Hello, Im new to this sub, microservices and golang in general but I wanted to learn but wasnt sure on something so I thought I would ask here. So I am attempting to build an app that shows stats about movie box office. I originally planned on it being a rest api monolithic app where I had 3 main endpoints which were film, charts and actors. Film would show box office summary for each film along with that movie's ranking on each chart, charts would show highest grossing movies and actors endpoint would show each actor's movies. I wanted to see if it even makes sense to even do this with microservices where I have a chartservice, filmservice and actorservice or am I going about this wrong? Also, there wont be any post requests from users since they will only get to view said data and not modify it. If not microservices I was thinking of using golang (gin or gorilla), mysql, react and maybe graphql since it seems so convenient for a traditional monolithic stack. Let me know your thoughts. Any feedback is appreciated.

I have some experience with managing Kubernetes (mostly cloud) clusters where I've been using Helm for some parts of the setup.

But I have never used it for deploying my own microservices.

As an example, I was working on a .NET application. We had 6 microservices deployed onto our Kubernetes cluster. Deployment for these was a basic setup - a deployment with pod definition, hpa, pod disruption budgets, service & ingress. Also this wasn't something that needed to be highly parametrized . We had some parameters like number of replicas for HPA or resource limits/requests varying between environments (mostly becuase for dev/test we have used much smaller clusters) but this was simple enough to parametrize it using our deployment pipeline in our CI/CD tool.

I see Helm shine when you want to redistribute your package to wider community or the set up is much more complex - let's say a cluster of RabbitMq nodes. It might support multiple deployment methods (deployments vs daemon sets) and very different configurations (HA nodes, mirrors, federation, persistence, backups, etc.) for different use cases. And in such case I see a real value of using Helm.

So far I've used Helm for installing things like nginx-ingress, aad-pod-identity (for Azure clusters) or secrets-store-csi-driver-provider-azure (https://github.com/Azure/secrets-store-csi-driver-provider-azure).

So I'm wondering if it's worth to package my own, project specific (so they won't be shared or used by any other projects) microservices using Helm?

So I'm tasked with coming up with student group projects for quite a number of high school students.

I received a problem statement from industry partner and I feel that the problem can be broken down into several different "management" system, user management, product management, category management, etc...

I'm currently feeling that it may be good to split each into one Microservice, get each student team to focus on each service's functionality, quality, and also integrate with other microservices.

I understand that most new project can benefit more by starting small as a monolithic and split into smaller microservices as it go, and as needed.

But do you think this may be a valid use case to start with microservice architecture? What are some things I should take note of?

Need some expert's foresight here as I'm quite noob with the Microservice architecture. Thanks in advance!

I have been responsible for maintaining about 20+ microservices, split based on their business logic domains, with a team of <5 developers for the past few years, and up until mid 2021, we hadn't had many issues keeping up with adding additional features, fixing bugs, and updating infrastructure.

However, last year, we started struggling to stay ahead of technical debt incurred by security remediation when our company fully implemented JFrog Artifactory as a replacement to Nexus (artifacts were rarely being blocked in Nexus). Our implementation of Artifactory blocks all artifacts with a medium severity or higher, which initially introduced a rather large remediation effort to be able to use it as our artifact repository, and since we have migrated, it has been common to suddenly see blocked versions of major frameworks such as Spring Boot, Spring Data, various NPM packages, etc..

Unfortunately, while our microservices aren't tightly coupled to each other, they do rely on many of the same major frameworks, so if a dependency gets blocked and requires a security update to a new major version to be compliant, we have to make similar changes across most, if not all of our microservices. Depending on the changes required to migrate to the new version, this effort could be minimal or MASSIVE. Deferral of the upgrade is possible, but limited to 30 days.

The additional technical debt from security remediation has me considering merging some of our microservices together, or potentially removing some common functionality, like database queries and similar work, out into separate microservices to reduce the number of microservices that are touched when an upgrade is needed. Currently, we are down to 2 developers and myself on the team, and it has become a challenge to get anything done outside of security remediation due to the duplicated efforts and testing required for the more impactful remediation.

Are there other teams out there facing the similar issues? If so, how did you manage to mitigate it?

TL;DR: Small team of developers having trouble managing technical debt on 20+ microservices that share frameworks/dependencies and would like to know if anyone else has faced similar struggles, and what solutions were employed to help mitigate the duplicated effort and complexity.

I am wondering if anyone out there is using Perl for microservices, cloud hosted services, and the like? What are your experiences and recommendations? This is the approach so many businesses want to take now, and I think Perl has some real strengths in being able to do with less complexity and faster development.

Where I work, we are starting development on Perl microservices to bring business continuity with our existing Perl monolith into their new microservices platform that has Java and Node in the mix. Things are going well so far and Perl has so many great options, but some real world insights are always useful.

I've worked with both microservice and monolithic web applications and have my own opinions about which I prefer most of the time. I'd like to hear other people's opinions and experiences with these architecture models. If you were designing a new enterprise web application, what would you consider when making these architecture decisions? What pros and cons do you see with microservice vs monolith?

So I and a couple of collegues that got hired in this fall is in a pretty unique situation due to our department being in what's essentially a "wait and see"-state, planning a highly sophisticated project that is going to take years to execute. In the meantime, me and my newly hired collegues get to practice on other fronts. In my case, I've got a project idea that was given to me in the "I've got these loose ideas for a piece of software that would be nice if it existed, but why don't you try to build it for practice, it's no biggie if it doesn't happen"-fashion. It's both very fun and challenging at the same time, as I get to practice not only plain old code but also architecture, database structure and everything in between. There is plenty of expertise within the org to ask for advice. Me and one more person are now actively building this (or were earlier last months, considering my vacation will end next week).

We started building the backend service first and the idea here was that we would use the same frameworks we will use later at our department, which in the case of the backend are Java-based. Specifically the framework we're using (Quarkus) is ideal for building a microservice architecture, so I thought - why don't we build a microservice for each resource/entity? We have quite a few entities, each needing a few endpoints, why don't we split them up a bit in microservices?

As I am progressing through video courses and documentation, it is dawning on me that this may be a really bad idea. Basically, we're preferably going to build the database structure and relations using an ORM (Hibernate with Panache in this case), and it seems like it would be almost impossible in practice to build relations if you don't have the entity classes in the same project structure. Then I saw this post, as well as this article, which contains some important info:

> Each service has to have its own database. If you break that rule, you introduce dependencies between your services. That makes them harder to develop, deploy and operate.

Since we're working with tables of the same db, we would break this rule.

All this above considered, I'm almost ready to pull the plug on the microservice architecture and migrate all the code to a monolith structure, but I

We have a "shared" layer that has a few resources accessed by different services in the project. There is a table storing shared information (user permission on each of the resources in the project, since it can get big so not being stored in JWT token)

Should we have a Lamba read the dynamoDB table and give other microservices access to the shared lambda only or should we give the microservices access to the table directly so that they can just use a lib method to read the permissions from the table? I am leaning towards direct DynamoDB table access since that avoids the extra hoop through a lambda.

Do you use a gateway server for that? If so, which one are you using? Is there any opensource gateway server you can recommend?

If not, what are you using to secure your microservices?

So, this might be a dumb question, but how would I go about setting autoscaling for a microservice? I'm checking container insights for the cluster, and there's been some serious CPU spikes in one service in particular. Now, here's where my ignorance comes in: pod scaling isn't the same as container scaling, yeah? So, how, if possible, do I get AKS to scale the microservice containers?

Hi everyone,

I'm curious about recommended strategies for capturing business metrics in applications, especially in highly distributed / microservice-based systems. The ideal world is that we can come up with business metrics/KPIs and then create dashboards to reflect those as we build to measure against the KPIs.

I'll try to explain through an example: Let's say it's an application that supports several task-oriented workflows. Metrics like the number of tasks created, time from task creation to completion, etc. Then, each workflow might have its own domain-centric metrics based on the data gathered during the tasks/workflow. Each domain's workflow/tasks interact with various services that support those specific domains. aka it's very distributed and the process might start in Service A, but end up in Service D, E, F based on the workflow.

The specific example isn't too important as is the concept that it's a very distributed application with related but different domains and the start/finish can be highly variable.

Added context: The system in question is very backend process-heavy, so there's a lot going on in the background. A given process can also have many touchpoints, many different users, and downtime between processes. So, it can't just be measured from Point A to Point B on the FE is a single session.

Options Explored:

• FE solutions like Google Analytics to capture events will only give a small piece of the overall process since much of it is BE processing, events, etc.
• Datadog, Dynatrace type services have custom metrics. This is the closest thing I've found, but it still feels like it's not set up to handle metrics across services. Where the metric might start in Service A, but end in Service D, E, or F.

Any suggestions are appreciated!

The method looks like this. Pretty much what the title says. I'm not sure how to do that and I'd appreciate if someone showed me an example.

I would like to split a monolith to microservices. I watched a udemy course where it said its ok to duplicate data so things can live on their own and work when others fail, but there are others that say its better not to duplicate data. Curious what the general consensus is (other than its an art, not a science)?

I've joined an org that's responsible for a robust, microservice -based b2b enterprise platform. The platform is proprietary/internal and is used to manage projects, automate research and billing, orchestrate workflows, create deliverables and send them to clients.

The platform is built on 23 microservices and an orchestration layer (with additional 1 or 2 microservices added per year). I don't have previous experience working with microservices but I get the impression that the team isn't set up for maximum success. My concern is that there are too many bottlenecks and that engineers essentially have blinders on, not getting the whole picture of what it is they're building. There are 6 product managers and +/-70 dev/qa's.

The current setup is that each microservice has it's own scrum team. There's a dev lead, a team of devs and QA. Some of the microservices are written in different languages, something that was the result of using the development teams the company had on hand. The Product Managers are all part of 3 or 4 scrum teams.

The result is that for every feature we work on, development needs to be federated across multiple scrum teams. Product Managers are much more involved in the "how" than in a typical org, because they're essentially breaking down tickets into which microservice is responsible for what part of making the feature work before handing them off to different scrum teams. They are also prioritizing other PM's stories and tickets within each scrum team/microservice.

The broad-stroke solution I'm looking at is: Working in scrum teams/pods that featured devs from each microservice.

In an effort to reduce the size of the post, I'll put the problems and potential solution in comments, but I'm sure many of you have already formed an idea of what the problems are based on this recap.

I'd love to hear insights, ideas, feedback, shared experiences, etc. **Edited to add the solution I'm considering.

I have a ton of old, legacy code. I'm curious where the line should be drawn where splitting into microservices. How do you choose what is too big or too small to be a microservice? Most tutorials I have seen show something so small it can basically be just a lambda function.

I am planning to create a saas application with microservice architecture, and some questions came up in my mind.

The full structure involves a react front-end, a first backend layer, and n "second level" microservices. At the moment I have only one "second level" microservice, others will come in the future.

My questions are:

1. The communication between the two ms will be done in http. I read about rpc but it's first time I see it. Should I move to rpc?
2. The performances will be acceptable?
3. In a situation the 1st backend should get some data from database, and then call the microservice to get some data too: This calls can be done in a cuncurrency way? Like both calls done at the same time.

I am quite worried about the bouncing of requests from front-end to backend to Ms. Of course the front-end can't reach the microservice directly because it's not exposed to the internet but it's in "Lan" with the backend.

I hope everything is clear. I can provide more details if you need it. Thanks!

I'm looking for a cheap / free service to play around in with a small full-stack application that does the following:

• Custom Domains
• SSL
• ReactJS FE (microservice in a Docker container)
• ExpressJS BE (microservice in a Docker container)
• NoSQL
• CI / CD from GitHub

It sounds like Heroku does this for about $7/mo.

The one thing I'm not sure about is the ability to deploy a FE and BE containers in a microservice pattern. The free plan says "Container Orchestration," but that could just be one container. How would this be handled Heroku?

I'm an enterprise application developer with 12 years of experience in developing enterprise software for multinational corporations. Right now, I work as an architect for a fintech unicorn. My role is to design and develop a scalable payment gateway system that could support 3000+ transactions per second. I have been working with microservices since 2014 and I have seen the strength and pitfalls of microservices in the last 6 years.

From interacting with different people of the same expertise, I realize that there is a common misconception that a shared database is an anti-pattern. Whenever I talk to an engineer, especially someone with < 8 years of experience, their idea about microservice is a stripped-down version of REST API with a single database per service. However, I wholeheartedly disagree with this idea. A microservice doesn't need to have a REST interface and it could very well use a shared database as long as it solves your business problem efficiently. What are your thoughts?

Edit: Just realized that the post is leading to an assumption that the current design I'm working on has a shared database design. The only scenario where we have a shared DB is when we have a CQRS implemented. Even then, the queries are connected to a read replica rather than the master database itself. The opinion is just a thought I came across while interacting with multiple senior engineers.

Hey, I've been manually coding the supported availability zones for Fargate (and other services) by looking up whether they are supported or not in the aws docs, but figure theres gotta be a way in terraform to do a filter or some kind of lookup on all supported availability zones for certain services. (e.g, fargate only being allowed in usw1-az1 & usw1-az3 in us-west-2).

For ec2 it is relatively easy where you can use the data lookup aws_ec2_instance_type_offerings and get the az's out of that but can't seem to find a way to do it for any other services and wondering if anyones had any luck in doing so, cheers.

Edit: Thanks for replies, looks like answer is unfortunately no.

Hello, Im new to this sub, microservices in general but I wanted to learn but wasnt sure on something so I thought I would ask here. So I am attempting to build a scalable app that shows stats about movie box office. I originally planned on it being a rest api monolithic app where I had 3 main endpoints which were film, charts and actors. Film would show box office summary for each film along with that movie's ranking on each chart, charts would show highest grossing movies and actors endpoint would show each actor's movies. I wanted to see if it even makes sense to even do this with microservices where I have a chartservice, filmservice and actorservice or am I going about this wrong? Also, there wont be any post requests from users since they will only get to view said data and not modify it. If not microservices I was thinking of using golang (gin or gorilla), mysql, react and maybe graphql since it seems so convenient for a traditional monolithic stack. Let me know your thoughts. Any feedback is appreciated.