Microservices Concepts - Complete Reference Guide
Communication
Service Discovery
- Mechanism for services to find and communicate with each other dynamically
- Examples: Consul, Eureka, etcd, ZooKeeper
Service Mesh
- Infrastructure layer for handling service-to-service communication
- Examples: Istio, Linkerd, Consul Connect
API Gateway
- Single entry point for all client requests
- Handles routing, composition, and protocol translation
Message Brokers
- Asynchronous communication infrastructure
- Examples: Kafka, RabbitMQ, ActiveMQ, AWS SQS, Azure Service Bus
REST API
- Representational State Transfer architectural style
- HTTP-based communication with standard methods (GET, POST, PUT, DELETE)
gRPC
- High-performance RPC framework using Protocol Buffers
- Binary protocol, faster than REST
GraphQL
- Query language for APIs
- Allows clients to request specific data structures
Event Bus
- Pub/Sub messaging backbone
- Enables event-driven communication
Load Balancer
- Distributes traffic across multiple service instances
- Examples: NGINX, HAProxy, AWS ELB
WebSockets
- Full-duplex communication protocol
- Real-time, bidirectional communication
Server-Sent Events (SSE)
- Server pushes updates to client over HTTP
- One-way real-time communication
Service-to-Service Communication
- Direct communication patterns between microservices
- Synchronous and asynchronous approaches
Asynchronous Messaging
- Non-blocking communication pattern
- Decouples services through message queues
Request-Reply Pattern
- Synchronous communication with response expectation
- Common in RPC and REST APIs
Publish-Subscribe Pattern
- One-to-many communication pattern
- Publishers send messages to topics, subscribers receive them
Point-to-Point Communication
- One-to-one message delivery
- Message consumed by single receiver
Choreography vs Orchestration
- Choreography: Decentralized coordination through events
- Orchestration: Centralized coordination through orchestrator
Patterns and Architecture Styles
API Gateway Pattern
- Provides unified interface to multiple microservices
- Handles cross-cutting concerns (auth, logging, rate limiting)
Saga Pattern
- Manages distributed transactions across multiple services
- Implements compensating transactions for rollback
CQRS (Command Query Responsibility Segregation)
- Separates read and write operations
- Different models for queries and commands
Event Sourcing
- Stores state changes as sequence of events
- Enables complete audit trail and time travel
Ambassador Pattern
- Proxy that handles networking tasks for service
- Offloads concerns like retry logic, monitoring
Sidecar Pattern
- Deploys helper component alongside main service
- Provides supporting features (logging, monitoring, proxying)
Strangler Fig Pattern
- Gradually replaces legacy system with new services
- Incremental migration strategy
Database per Service
- Each microservice owns its database
- Ensures loose coupling and independence
API Composition Pattern
- Aggregates data from multiple services
- Creates unified response for clients
Backend for Frontend (BFF)
- Separate backend for each frontend type
- Optimized for specific client needs
Anti-Corruption Layer
- Translates between different domain models
- Protects clean architecture from legacy systems
Circuit Breaker Pattern
- Prevents cascade failures
- Fails fast when service is unavailable
Bulkhead Pattern
- Isolates resources to prevent total system failure
- Limits impact of failures to specific partitions
A ship has bulkheads (walls) dividing it into compartments.
If one compartment floods →
the flooding is contained → the ship does not sink.
Retry Pattern
- Automatically retries failed operations
- Handles transient failures
Timeout Pattern
- Sets maximum wait time for operations
- Prevents indefinite blocking
Microservices Chassis
- Reusable framework for microservices
- Common infrastructure code (logging, config, health checks)
Service Registry Pattern
- Centralized directory of service instances
- Enables dynamic service discovery
Decomposition Patterns
- By Business Capability: Services organized around business functions
- By Subdomain: DDD-based decomposition along domain boundaries
Externalized Configuration
- Configuration stored outside application code
- Enables environment-specific settings
Consumer-Driven Contract
- Consumers define API contract expectations
- Ensures backward compatibility
Transactional Outbox Pattern
- Ensures reliable event publishing
- Stores events in database, then publishes
Event-Driven Architecture
- Services communicate through events
- Loose coupling and asynchronous processing
Domain-Driven Design (DDD)
- Strategic design approach focusing on domain model
- Ubiquitous language and bounded contexts
Bounded Context
- Explicit boundary within which domain model applies
- Clear separation between different domains
Aggregate Pattern
- Cluster of domain objects treated as single unit
- Ensures consistency within boundary
Two-Phase Commit (2PC)
- Distributed transaction protocol
- Coordinates commit across multiple databases
Idempotency Pattern
- Operations produce same result when executed multiple times
- Critical for retry scenarios
Reliability
Circuit Breaker
- Monitors for failures and prevents further calls
- Three states: Closed, Open, Half-Open
Retry Logic
- Automatic retry of failed operations
- Exponential backoff and jitter
Timeout Management
- Prevents indefinite waits
- Configured timeouts for all operations
Bulkhead Pattern
- Resource isolation strategy
- Prevents cascading failures
Health Checks
- Endpoint exposing service health status
- Used by orchestrators and load balancers
Graceful Degradation
- Maintains partial functionality during failures
- Provides reduced service rather than complete failure
Fault Tolerance
- System continues operating despite failures
- Redundancy and resilience mechanisms
Self-Healing
- Automatic recovery from failures
- Auto-restart, auto-scaling, and self-repair
Redundancy
- Multiple instances of critical components
- Eliminates single points of failure
Load Balancing
- Distributes requests across instances
- Improves availability and performance
Fallback Pattern
- Alternative action when primary operation fails
- Provides cached data or default response
Rate Limiting
- Controls request rate to prevent overload
- Protects against abuse and ensures fair usage
Backpressure
- Flow control mechanism
- Prevents overwhelming downstream services
Dead Letter Queue
- Stores messages that cannot be processed on consumer and later proccessed
- Enables later analysis and reprocessing
Compensating Transaction
- Undoes effects of completed transactions
- Used in saga pattern for rollback
Idempotent Operations
- Safe to retry without side effects
- Critical for reliable distributed systems
Chaos Engineering
- Deliberately introduces failures
- Tests system resilience and recovery
Data Management
Consistency Models
ACID Transactions
- Atomicity, Consistency, Isolation, Durability
- Strong consistency guarantees
Eventual Consistency
- System eventually reaches consistent state
- Allows temporary inconsistencies
BASE Model
- Basically Available, Soft state, Eventual consistency
- Alternative to ACID for distributed systems
Strong Consistency
- All nodes see same data simultaneously
- Highest consistency level
Weak Consistency
- No guarantee when updates will be visible
- Best-effort consistency
Causal Consistency
- Preserves cause-effect relationships
- Operations appear in causal order
Where to Keep the Data
Database per Service
- Each service owns its data store
- Ensures autonomy and loose coupling
Schema per Service
- Separate database schemas per service
- Logical isolation within shared database
Polyglot Persistence
- Different databases for different services
- Choose best technology for each use case
Shared Database
- Multiple services access same database
- Anti-pattern, creates tight coupling
Data Replication
- Copies data across multiple locations
- Improves availability and performance
Data Synchronization
- Keeps multiple data copies consistent
- Batch or real-time synchronization
Data Sharing & Caching
Distributed Caching
- Cache shared across multiple instances
- Examples: Redis, Memcached, Hazelcast
Cache Invalidation
- Removes stale data from cache
- Strategies: TTL, event-based, manual
Cache-Aside Pattern
- Application manages cache explicitly
- Read from cache, write to database
Write-Through Cache
- Writes go through cache to database
- Ensures cache is always current
Write-Behind Cache
- Writes to cache, asynchronously to database
- Improves write performance
Cache Coherence
- Ensures consistency across distributed caches
- Synchronization mechanisms
API Composition
- Combines data from multiple services
- Performed by API gateway or dedicated service
Data Aggregation
- Combines and processes data from multiple sources
- Creates unified view
Additional Data Concepts
Event Store
- Database optimized for event sourcing
- Append-only storage of events
Change Data Capture (CDC)
- Tracks database changes
- Enables real-time data synchronization
Data Lake/Data Warehouse
- Centralized repository for analytics
- Aggregates data from multiple services
Read Replicas
- Read-only database copies
- Improves read performance
Sharding
- Horizontal partitioning of data
- Distributes data across multiple databases
Partitioning
- Divides data into smaller segments
- Improves performance and manageability
Data Migration Strategies
- Approaches for moving data between systems
- Online, offline, or hybrid migration
Database Versioning/Schema Evolution
- Managing database schema changes
- Migration scripts and version control
Saga Orchestrator vs Choreography
- Orchestrator: Central coordinator manages saga
- Choreography: Services coordinate through events
Observability and Tracing
Logging
Centralized Logging
- Aggregates logs from all services
- Examples: ELK Stack (Elasticsearch, Logstash, Kibana), Splunk
Log Aggregation
- Collects logs from multiple sources
- Enables unified searching and analysis
Structured Logging
- Logs in consistent, parseable format
- JSON or key-value pairs
Log Levels
- Severity levels: DEBUG, INFO, WARN, ERROR, FATAL
- Controls verbosity
Tracing
Distributed Tracing
- Tracks requests across multiple services
- Shows complete request path and timing
Request Tracing
- Follows single request through system
- Identifies performance bottlenecks
Trace Sampling
- Records subset of traces
- Reduces overhead while maintaining visibility
Correlation IDs
- Unique identifier for request chain
- Links logs and traces across services
Monitoring
Metrics Collection
- Gathers performance and health metrics
- Time-series data storage
Health Monitoring
- Continuous health status checking
- Detects failures and anomalies
Performance Monitoring
- Tracks response times, throughput, errors
- Identifies performance degradation
Alerting
- Notifies teams of issues
- Rule-based and anomaly detection
Dashboard Visualization
- Visual representation of metrics
- Real-time system overview
Additional Observability
APM (Application Performance Monitoring)
- End-to-end performance monitoring
- Examples: New Relic, Datadog, AppDynamics
Observability Pillars
- Logs: What happened
- Metrics: How much/how many
- Traces: Where and how long
Service Mesh Observability
- Built-in observability from service mesh
- Examples: Istio, Linkerd telemetry
OpenTelemetry
- Vendor-neutral observability framework
- Unified APIs for logs, metrics, traces
Prometheus
- Time-series metrics database
- Pull-based metrics collection
Grafana
- Visualization and analytics platform
- Creates dashboards from multiple sources
Jaeger/Zipkin
- Distributed tracing systems
- Visualizes request flows
Synthetic Monitoring
- Simulates user interactions
- Proactive performance testing
Real User Monitoring (RUM)
- Tracks actual user experiences
- Frontend performance monitoring
Error Tracking
- Captures and aggregates errors
- Examples: Sentry, Rollbar, Bugsnag
Deployment
Blue-Green Deployment
- Two identical environments (blue and green)
- Switch traffic between them for zero-downtime
Canary Deployment
- Gradual rollout to subset of users
- Monitor before full deployment
Rolling Deployment
- Incremental replacement of instances
- Reduces risk and downtime
Feature Flags
- Toggle features on/off without deployment
- Enables A/B testing and gradual rollout
Shadow Traffic
- Duplicates production traffic to new version
- Tests without affecting users
A/B Testing
- Compares different versions
- Data-driven feature decisions
Container Orchestration
- Manages containerized applications
- Examples: Kubernetes, Docker Swarm, ECS
Service Virtualization
- Simulates dependencies for testing
- Enables parallel development
Infrastructure as Code (IaC)
- Defines infrastructure through code
- Examples: Terraform, CloudFormation, Pulumi
GitOps
- Git as single source of truth
- Automated deployment from Git
CI/CD Pipelines
- Continuous Integration and Continuous Deployment
- Automated build, test, and deploy
Immutable Infrastructure
- Infrastructure never modified after creation
- Replace rather than update
Zero-Downtime Deployment
- Deploy without service interruption
- Rolling updates and load balancer coordination
Rollback Strategies
- Quick revert to previous version
- Automated rollback on failure
Multi-Region/Multi-Cloud Deployment
- Deploy across geographic regions
- Improves availability and disaster recovery
Security
Authentication
- Verifying user/service identity
- OAuth 2.0, OpenID Connect, JWT
Authorization
- Controlling access to resources
- RBAC (Role-Based), ABAC (Attribute-Based)
API Key Management
- Secure generation and storage of API keys
- Rotation and revocation
Token Management
- JWT tokens, refresh tokens
- Secure token storage and validation
Encryption
- TLS/SSL for data in transit
- Encryption at rest for sensitive data
Certificate Management
- Managing SSL/TLS certificates
- Automated renewal and rotation
API Rate Limiting
- Limits requests per time period
- Prevents abuse and ensures fair usage
API Throttling
- Controls request rate dynamically
- Based on user, service, or system load
Security at API Gateway
- Centralized security enforcement
- Authentication, authorization, threat detection
Mutual TLS (mTLS)
- Two-way certificate authentication
- Service-to-service security
Service-to-Service Authentication
- Secures internal communication
- Service accounts and certificates
Secrets Management
- Secure storage of sensitive data
- Examples: HashiCorp Vault, AWS Secrets Manager, Azure Key Vault
Identity Provider (IdP) Integration
- Centralized identity management
- Examples: Okta, Auth0, Azure AD
API Gateway Security
- Protection at entry point
- WAF, DDoS protection, threat detection
DDoS Protection
- Mitigates distributed denial-of-service attacks
- Rate limiting and traffic filtering
Input Validation & Sanitization
- Prevents injection attacks
- Validates all user input
OWASP Security Practices
- Following OWASP Top 10 guidelines
- Security best practices
Zero Trust Architecture
- Never trust, always verify
- Assumes breach and verifies every request
Network Policies & Segmentation
- Isolates services at network level
- Limits lateral movement
Testing
Unit Testing
- Tests individual components in isolation
- Fast and automated
Integration Testing
- Tests interaction between components
- Verifies interfaces and data flow
Contract Testing
- Validates API contracts between services
- Ensures compatibility
End-to-End (E2E) Testing
- Tests complete user workflows
- Validates entire system
Chaos Testing
- Introduces failures deliberately
- Validates resilience and recovery
Performance Testing
- Measures system performance under load
- Response time, throughput, resource usage
Load Testing
- Tests system under expected load
- Identifies capacity limits
Smoke Testing
- Quick verification of critical functionality
- Basic sanity check after deployment
Mutation Testing
- Tests quality of test suite
- Introduces code mutations to find weaknesses
Service Virtualization Testing
- Tests with simulated dependencies
- Enables isolated testing
Security Testing
- SAST: Static Application Security Testing
- DAST: Dynamic Application Security Testing
- Penetration Testing: Simulated attacks
Regression Testing
- Ensures new changes don’t break existing functionality
- Automated test suite execution
Compliance Testing
- Validates regulatory compliance
- GDPR, HIPAA, PCI-DSS
Consumer-Driven Contract Testing
- Consumers define contract expectations
- Example: Pact framework
Scalability
Horizontal Scaling
- Adding more instances
- Scale out rather than up
Vertical Scaling
- Increasing instance resources
- Scale up with more CPU/memory
Auto-Scaling
- Automatic adjustment of resources
- Based on metrics and demand
Elastic Load Balancing
- Dynamic load distribution
- Adapts to changing capacity
Stateless Services
- Services don’t store session state
- Enables easy scaling
Connection Pooling
- Reuses database connections
- Improves performance and resource usage
Throttling
- Controls request rate
- Prevents overload
Queue-Based Load Leveling
- Uses queues to smooth traffic spikes
- Decouples processing from requests
Configuration Management
Centralized Configuration
- Configuration stored in central location
- Examples: Spring Cloud Config, Consul, etcd
Environment-Specific Configurations
- Different configs for dev, staging, production
- Environment variables and profiles
Dynamic Configuration Updates
- Update configuration without restart
- Real-time configuration changes
Feature Toggles/Flags Management
- Centralized feature flag management
- Examples: LaunchDarkly, Unleash
Configuration Versioning
- Track configuration changes
- Rollback capability
Service Governance
Service Catalog
- Centralized registry of services
- Documentation and metadata
API Versioning
- Managing API changes over time
- URI versioning, header versioning, content negotiation
Backward Compatibility
- New versions support old clients
- Graceful deprecation
Deprecation Strategy
- Phased removal of old APIs
- Communication and migration support
Service Lifecycle Management
- Managing service from creation to retirement
- Standardized processes
SLA/SLO/SLI Management
- SLA: Service Level Agreement (contract)
- SLO: Service Level Objective (target)
- SLI: Service Level Indicator (measurement)
Development & Tooling
Service Templates/Scaffolding
- Pre-configured project templates
- Standardizes service structure
Local Development Environment
- Tools for local development
- Docker Compose, Minikube, Kind
API Documentation
- Automated API documentation
- Swagger/OpenAPI, AsyncAPI
Code Generation
- Generates code from specifications
- Reduces boilerplate
Service Mocking
- Simulates service behavior
- Enables parallel development
Cost Optimization
Resource Optimization
- Right-sizing instances
- Efficient resource utilization
Cost Monitoring
- Track and analyze costs
- Identify optimization opportunities
Reserved Instances
- Commitment-based discounts
- Long-term cost reduction
Spot/Preemptible Instances
- Use excess capacity at reduced cost
- For non-critical workloads
Auto-Scaling Policies
- Scale down during low usage
- Optimizes cost vs performance
Storage Optimization
- Archive old data
- Use appropriate storage tiers
Resource Tagging
- Tag resources for cost allocation
- Enables cost tracking by team/project
Best Practices Summary
- Design for Failure: Assume failures will happen
- Decentralization: Avoid single points of failure
- Automation: Automate testing, deployment, and operations
- Observability: Build comprehensive monitoring from the start
- Security: Apply security at every layer
- Documentation: Maintain clear API and architecture documentation
- Standardization: Use consistent patterns and practices
- Continuous Improvement: Regularly review and optimize
References and Tools
Popular Tools by Category
- Container Orchestration: Kubernetes, Docker Swarm, ECS, EKS
- Service Mesh: Istio, Linkerd, Consul Connect
- API Gateway: Kong, AWS API Gateway, Azure API Management
- Monitoring: Prometheus, Grafana, Datadog, New Relic
- Tracing: Jaeger, Zipkin, AWS X-Ray
- Logging: ELK Stack, Splunk, Loki
- Message Brokers: Kafka, RabbitMQ, AWS SQS, Azure Service Bus
- Databases: PostgreSQL, MongoDB, Cassandra, DynamoDB
- Caching: Redis, Memcached, Hazelcast
- CI/CD: Jenkins, GitLab CI, GitHub Actions, CircleCI
- IaC: Terraform, CloudFormation, Pulumi, Ansible