Microservices Interview Q&A: Java & Spring Boot Edition

What is a microservice?

A microservice is a small, independent software component that performs a specific business function within a larger application.

How does a microservices architecture differ from a monolithic architecture?

Microservices architecture consists of loosely coupled, independently deployable services, while monolithic architecture is a single, tightly integrated application.

Definition and core concepts Microservices are an architectural style where an application is composed of small, autonomous services that communicate via APIs.

Advantages of using Microservices Benefits include scalability, flexibility, faster development cycles, and easier maintenance of individual components.

Understanding Single Responsibility Principle with a Diagram The Single Responsibility Principle states that each service should have one, and only one, reason to change.

Single Responsibility Principle Each microservice should be responsible for a single part of the functionality, promoting modularity and separation of concerns.

Bounded Contexts Bounded contexts are logical boundaries that encapsulate related functionality and data as a cohesive unit within a larger system.

Domain-Driven Design (DDD) in microservices DDD is an approach to software design that aligns the architecture with the business domain, often used in microservices.

Service decomposition strategies Techniques for breaking down a monolithic application into microservices based on business capabilities or sub-domains.

API design and versioning Designing consistent, well-documented APIs and managing their evolution over time to ensure backward compatibility.

Event-driven architecture A design pattern where services communicate through events, enabling loose coupling and asynchronous processing.

Synchronous vs. asynchronous communication Comparing direct, real-time communication (synchronous) with message-based, non-blocking communication (asynchronous) between services.

RESTful APIs Representational State Transfer (REST) is an architectural style for designing networked applications, commonly used in microservices.

Message queues and event streaming Technologies like RabbitMQ or Apache Kafka that enable asynchronous communication and event processing between microservices.

Saga pattern A way to manage distributed transactions across multiple services, maintaining data consistency in a microservices architecture.

Bulkhead pattern Isolating elements of an application into pools so that if one fails, the others will continue to function.

Circuit Breaker pattern A design pattern that stops the flow of requests to a service if it's not responding, preventing cascading failures.

Database per service pattern Each microservice has its own database, ensuring loose coupling and independent scalability.

Distributed transactions Managing transactions that span multiple services, ensuring data consistency across a distributed system.

CQRS and Event Sourcing Command Query Responsibility Segregation (CQRS) separates read and write operations, often used with Event Sourcing to capture all changes as a sequence of events.

Polyglot persistence Using different types of data storage technologies for different microservices based on their specific needs.

Service registry and discovery patterns Mechanisms for services to register themselves and discover other services in a dynamic microservices environment.

Client-side vs. server-side load balancing Comparing approaches to distributing traffic across multiple service instances, either at the client or through a dedicated load balancer.

Service mesh concepts An infrastructure layer for handling service-to-service communication, providing features like traffic management and security.

Containerization (Docker) Using container technology to package and run microservices in isolated environments.

Orchestration (Kubernetes) Managing, scaling, and deploying containerized microservices across a cluster of machines.

CI/CD for microservices Continuous Integration and Continuous Deployment practices adapted for microservices development and deployment.

Distributed tracing Tracking and visualizing requests as they flow through multiple services in a microservices architecture.

Centralized logging Aggregating logs from multiple microservices into a central system for easier monitoring and troubleshooting.

Health checks and circuit breakers Monitoring the health of services and preventing cascading failures in a microservices system.