Microservices Migration

Why might a company choose to migrate from a monolithic architecture to a microservices architecture?

• Because Netflix uses microservices

• Easier Maintenance

• To upgrade my LinkedIn profile

• Improved Fault Isolation

What is the first step in transforming a monolithic application into a microservice?

• Deploying all components on the cloud

• • Splitting the database

• Identifying bounded contexts, scalability and deployment needs

• Writing new code from scratch

Answer explanation

Bounded contexts help in defining clear boundaries within the application, making it easier to break down into smaller, manageable services.

Which of the following is NOT a common challenge when migrating from a monolith to microservices?

• Increased operational complexity

• Data consistency issues

• Reduced development effort

• Network latency

Answer explanation

While development of individual microservices might be faster, overall project complexity often increases.

Which communication pattern is often preferred between microservices?

• Synchronous RPC (Remote Procedure Call)

• Asynchronous messaging (e.g., Kafka, RabbitMQ)

• Shared database

• Direct HTTP requests

Answer explanation

Asynchronous messaging provides better decoupling and scalability.

Sharing a database tightly couples microservices and can hinder independence, and while possible, direct HTTP requests can lead to tight coupling and performance issues.

What is NOT a best practices on how to split into services?

• Consider ROI, scalability, and maintainability when defining services

• Each service should have exactly one function

• Services should aim for independent development and deployment

• Design services around capabilities and bounded contexts

Answer explanation

Over-abstraction leads to anemic services, which increase complexity and create coupling between services.

Which strategy is commonly used to incrementally move to microservices?

• Strangler pattern

• Continuous integration

• Big bang rewrite

• Hexagonal architecture

Answer explanation

The strangler pattern involves gradually replacing parts of the monolith with microservices, allowing for a smooth transition without disrupting the entire system.

What is a good way to ensure data consistency across microservices?

• By using GRPC and Protocol Buffers

• • By using a single, central database

• By implementing eventual consistency

• • By using SQL ACID transactions

Answer explanation

Eventual consistency allows the system to remain scalable while ensuring that all changes will propagate and synchronize over time, maintaining data integrity.

During a migration, how can we create services that still rely on data owned by the monolith?

• by creating a migration API on the monolith that provides endpoints that are similar to those later provided by dedicated services

• by running a job that copies data to a migration database to be used by the services that need it

• You have to plan the migration so that this doesn't happen. A service must not call back into the monolith.

• by exposing the monolith's database to the microservices

Answer explanation

A migration API is a controlled way to expose data from the monolith in a way that doesn't leak too much implementation logic to the services. Ideally, they can then switch to using another service by changing an endpoint.

What is the tool of choice to migrate to new functionality on-the-fly?

• Blue/green deployments

• Feature toggles

• a second monolith serving the new code

• a migration API

Answer explanation

With feature toggles new functionality can be switched on and off during runtime. This is a good way to transition to a service on-the-fly.

What is NOT a good component to migrate first?

• a central component, as many other services will later depend on it

• a component that needs to be deployed much more frequently due to frequent business requirements

• a component that has strong test coverage and little related technical debt

• a rather small capability that does not have many dependencies

Answer explanation

Small and independent capabilities are a good first migration target as they allow you to learn as you go without having to consider too many side-effects.