Microservices Architecture
The microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP or gRPC API.
Planning
Designing
Developing
Microservices Architecture
The microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP or gRPC API.
Microservices are built around business capabilities and independently deployable by fully automated deployment process.
Microservices architecture decomposes an application into small independent services that communicate over well-defined APIs. Services are owned by small, self-contained teams
Microservices architecture is a cloud native architectural approach in which services composed of many loosely coupled and independently deployable smaller components.
Microservices have their own technology stack, communicate to each other over a combination of REST APIs, are organized by business capability, with the bounded contexts.
Following Single Responsibility Principle that referring separating responsibilities as per services.
Benefits of a Microservices Architecture
Agility, Innovation and Time-to-market
Microservices architectures make applications easier to scale
and faster to develop, enabling innovation and accelerating
time-to-market for new features.
Flexible Scalability
Microservices can be scaled independently, so you scale out
sub-services that require less resources, without scaling out
the entire application.
Small, focused teams
Microservices should be small enough that a single feature
team can build, test, and deploy it.
Small and separated code base
Microservices are not sharing code or data stores with other
services, it minimizes dependencies, and that makes easier
to adding new features.
Easy Deployment
Microservices enable continuous integration and continuous
delivery, making it easy to try out new ideas and to roll back
if something doesn’t work.
Technology agnostic, Right tool for the job
Small teams can pick the technology that best fits their
microservice and using a mix of technology stacks on their
services.
Resilience and Fault isolation
Microservices are fault toleranced and handle faults correctly
for example by implementing retry and circuit breaking
patterns.
Data isolation
Databases are separated with each other according to
microservices design. Easier to perform schema updates,
because only a single database is affected.
Challenges of a Microservices Architecture
Complexity
Each service is simpler, but the entire system is more
complex. Deployments and Communications can be
complicated for hundreds of microservices.
Network problems and latency
Microservice communicate with inter-service communication,
we should manage network problems. Chain of services
increase latency problems and become chatty API calls.
Development and testing
Hard to develop and testing these E2E processes in
microservices architectures if we compare to monolithic
ones.
Data integrity
Microservice has its own data persistence. Data consistency
can be a challenge. Follow eventual consistency where
possible
Deployment
Deployments are challenging. Require to invest in quite a lot
of devops automation processes and tools. The complexity
of microservices becomes overwhelming for human
deployment.
Logging & Monitoring
Distributed systems are required to centralized logs to bring
everything together. Centralized view of the system to
monitor sources of problems.
Debugging
Debugging through local IDE isn’t an option anymore. It
won’t work across dozens or hundreds of services.