Moving to Microservices: What We Learned at MKC
Code Optimization Techniques: Boosting Your Program’s Speed
May 10, 2024
How to Improve User Experience in Mobile Apps
June 19, 2024
Introduction
Software development has been changing a lot lately. Many companies, including EVD Technology, are shifting from big, complex systems (called monoliths) to a more flexible way of building software—microservices. This change brings a lot of good things, like making our systems more scalable, easier to work with, and simpler to maintain. But it's not all easy sailing; there are some challenges we've got to tackle along the way.
Understanding the Transition
What's a Monolith?
In a monolithic system, everything's bundled together tightly. It's like having one giant piece where all parts are connected. This setup often causes problems when we need to make things bigger, fix stuff, or put new things in.
Enter Microservices
Now, with microservices, we break that giant piece into smaller bits, kind of like building with LEGO. Each bit (or service) does its own thing and talks to others using specific rules (like APIs). This makes it easier to work on different parts independently.
The Good Stuff About Microservices
- Scalability: We can grow only the parts that need to grow, not everything.
- Flexibility and Speed: It's like working on separate projects that fit together, making changes quicker.
- Safety Net: If something goes wrong in one part, it won't bring down the whole system. Think of it like having backup plans in place.
Struggles with Microservices: EVD's Story
Challenges We Faced
EVD Technology decided to use microservices with Next.js for a new project. Even though this approach sounded awesome, it wasn't without its bumps in the road.
Common Problems We Encountered
1. Shifting from Big to Smaller Parts
The Challenge: It was tough reshaping our software from one big thing to smaller, more manageable pieces. We had to make sure everything still worked while breaking it apart.
Our Solutions:
- Taking It Step-by-Step: We didn't rush; we took small pieces and moved them bit by bit.
- Creating a New Gateway: We built a special door (an API gateway) that lets everything talk to each other nicely.
2. Handling Different Code Styles and TypeScript
The Challenge: We had code that used a different style and a new language (TypeScript) to learn. It was like speaking a different language suddenly!
What We Did:
- Learning the New Way: We slowly adapted our code to this new way of doing things, kind of like learning new words in a language.
- Making Types Clear: We made sure that everything had clear definitions so everyone understood what they were dealing with.
3. Making Sure Everything Spoke the Same Language
The Challenge: Getting all our bits to talk to each other was a puzzle. Sometimes, they just didn't understand each other.
Our Fixes:
Creating Shared Rules: We made strict rules about how things should talk, making sure everyone understood each other's 'language'.
- Using Special Tools: We found tools that helped our different parts understand each other better.
How We Managed:
- Automating the Search: We used special tools that helped our bits find each other without getting lost.
- Setting Up a Meeting Point: We created a central place (an API gateway) where all the bits could meet and talk.
5. Building Good Communication Roads
The Challenge: Making sure our different bits communicated properly with each other, like good teamwork.
Our Solutions:
- Making Clear Paths: We drew out clear routes (APIs) for our bits to talk and share stuff.
- Writing Down Everything: We made sure everyone knew how to talk to each other by writing down clear rules (documentation).
Moving to microservices wasn't easy, but with these solutions, EVD Technology managed to navigate the challenges, ensuring our software works better in smaller, more manageable bits.
Conclusion
Switching from big systems to microservices is a big task but comes with many benefits. EVD Technology faced challenges when adopting microservices with Next.js, but by taking small steps, learning new things, and ensuring clear communication between different parts, we've made great strides toward a more efficient and adaptable system.
