Microservices divide the system into small, independent services. For mobile apps, this means scalable and evolving APIs. This guide introduces how to implement and operate microservices for applications.
What are Microservices
Definition
Architecture where application is composed of small and independent services.
Features
- Deployment independence
- Sole responsible for domain
- Communication via network
- May have different technologies
Monolith Difference
Monolith: all together. Microservices: separated by responsibility.
Advantages
Independent Scalability
Each service scales according to demand.
Independent Deployment
Updating one does not affect others.
Resilience
Failing one doesn't bring it all down.
Multiple Technologies
Use the best tool for each job.
Independent Teams
Clear ownership, fewer dependencies.
Disadvantages
Operational Complexity
More parts to manage.
Network Latency
Communication between services adds latency.
Hard Debugging
Track issues across services.
Data Consistency
Distributed transactions are complex.
Overhead
For small systems, it may be too much.
When to Use
Good For
- Large teams
- Complex domains
- Need for independent scale
- Frequent evolutions
Avoid
- Small teams
- MVP
- Simple domains
Decomposition
By Domain
Bounded DDD contexts.
By Functionality
Auth, payments, catalog, etc.
By Use Case
Independent user flows.
API Gateway
Function
Single entry point for clients.
Responsibilities
Routing, authentication, rate limiting, aggregation.
Tools
Kong, AWS API Gateway, Nginx.
BFF (Backend for Frontend)
Concept
Specific gateway for client type.
Usage
BFF for mobile, another for web.
Advantages
Optimized for each client.
Communication
Synchronous
REST, gRPC. Request/response.
Asynchronous
Message queues. Events.
Trade-offs
Synchronous is simple, asynchronous is resilient.
Service Discovery
Problem
How do services find each other?
Solutions
Consul, Kubernetes DNS, AWS Cloud Map.
Observability
Logging
Centralized logs with correlation ID.
Tracing
Distributed tracing with Jaeger, X-Ray.
Metrics
By service and aggregate.
Resilience
Circuit Breaker
Stop calling failed service.
Retry
Try again with backoff.
Timeout
Don't wait forever.
###Bulkhead
Isolate resources.
Data Management
Database per Service
Each service with its bank.
Eventual Consistency
Avoided distributed transactions.
Events
Communicate changes via events.
Sagas
Long transactions via clearing.
Deployment
Containers
Docker to encapsulate services.
Orchestration
Kubernetes to manage.
CI/CD
Pipeline per service.
Blue-Green/Canary
Secure deployments.
For Mobile
Optimized API
Fewer calls, aggregated data.
Cache
CDN and API caching.
###Offline
Resilience when network fails.
Versioning
Versioned APIs for compatibility.
Testing
###Unit
For service.
Integration
Communication between services.
###Contract
Consumer and provider agree on contract.
End-to-End
Complete flows through services.
Migration
Strangler Pattern
Gradually replaces monolith.
Start Small
Start with a service.
###Extract
Identify well-defined domains.
Common Errors
Premature Distribution
Microservices before you need them.
Nano-services
Services too small.
No Observability
Impossible to debug.
Ignore Latency
Multiple network calls.
Conclusion
Microservices offer scalability and flexibility, but with complexity. Evaluate if necessary for your context, invest in observability and operate with discipline. For mobile apps, focus on optimized APIs and resiliency.
##FAQs
1) Do I need Kubernetes for microservices? Not necessarily. But it helps a lot at scale.
2) How many services is too many? There is no magic number. If the team can't manage it, it's too much.
3) Mobile should directly call microservices? Generally not. Use API Gateway or BFF.
4) Are microservices always better? No. Well-made monolith can be better for many cases.
5) How to start with microservices? Start modular monolith. Extract when needed.
Also read
- Backend for Applications: Architecture, Technologies and Best Practices
- Monolith vs Microservices: Which Architecture to Choose
- Scalable Software Architecture: How to Build Systems that Grow
- Scalable Software Architecture - Best Practices for Scaling
- Scalable Software Architecture - Best Practices for Startups
- Scalable Software Architecture - Best Practices for Small Teams