Interview Questions

Microservices provide scalability, flexibility, ease of deployment, better fault isolation, and technology diversity, allowing teams to work independently on different services.

Spring Boot is a Java framework used to create standalone, production-ready applications. It simplifies microservices development by providing features like embedded servers, simplified configurations, and easy dependency management.

An API Gateway acts as an entry point for client requests. It routes requests to the appropriate microservices, handles authentication, logging, rate limiting, and load balancing. Examples include Netflix Zuul, Spring Cloud Gateway, and Kong.

Microservices communicate with each other via HTTP/REST (synchronous communication) or message brokers like RabbitMQ or Kafka (asynchronous communication).

Service Discovery is the process where microservices dynamically register themselves and discover other services. Tools like Eureka or Consul are used to automatically find and connect microservices without hardcoding their locations.

Use global exception handling mechanisms like @ControllerAdvice in Spring Boot, combined with proper error codes and meaningful error messages. Implement centralized logging and monitoring for error tracking across services.

Use eventual consistency models, where services publish events to notify others of data changes, or implement Sagas and event-driven architecture to manage distributed transactions across services.

The Circuit Breaker pattern prevents a service from repeatedly calling a failing service by stopping the requests after a threshold and returning fallback responses. This ensures the system remains responsive. Tools like Resilience4j or Hystrix can be used to implement it.

A Load Balancer distributes incoming requests across multiple instances of a service to ensure reliability and scalability. Spring Cloud LoadBalancer or Netflix Ribbon can be used for this purpose.

A REST API (Representational State Transfer) is an architectural style that allows services to communicate over HTTP by exchanging JSON or XML data. It is commonly used to expose microservices to the outside world.

Secure microservices using OAuth 2.0, JWT tokens for authentication and authorization, and use SSL/TLS for secure communication. Service-to-service communication can be secured using mutual TLS.

In a microservices architecture, logs are distributed across multiple services and servers. Centralized logging tools like ELK Stack (Elasticsearch, Logstash, Kibana) or Graylog collect, aggregate, and analyze logs in one place for easier debugging and monitoring.

Use Spring Boot Actuator to expose health endpoints (/actuator/health) that provide details about the health of microservices, such as database connectivity, memory usage, and third-party service availability.

In synchronous communication, services directly interact and wait for each other’s response (e.g., via REST). In asynchronous communication, services communicate indirectly using message brokers, allowing services to continue processing without waiting for a response.

Challenges include increased complexity in managing distributed systems, data consistency issues, network latency, monitoring multiple services, and the need for robust deployment pipelines.

Docker is a containerization platform that packages microservices along with their dependencies into isolated containers. It ensures consistency across environments and simplifies the deployment and scaling of microservices.

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications, including microservices. It manages clusters of containers for better resource utilization and scaling.

Polyglot persistence means using different databases for different microservices, depending on their requirements. Each microservice manages its database independently, which allows for flexibility and optimization.

Versioning is important to ensure backward compatibility. APIs can be versioned using URI versioning (e.g., /v1/resource), header-based versioning, or query parameters.

The database-per-service pattern ensures that each microservice owns and manages its own database, avoiding tight coupling between services and promoting scalability and flexibility. It allows microservices to evolve independently.

Hystrix is a library that implements the Circuit Breaker pattern, allowing services to handle failures gracefully and prevent cascading failures by stopping further calls to a failing service.

An API Gateway is a single entry point for all client requests in a microservices architecture. It handles routing, authentication, rate limiting, and service discovery. It also aggregates responses from multiple microservices if necessary.

Distributed transactions involve multiple services and databases. In microservices, it's challenging to maintain ACID transactions across services. Use patterns like Sagas and eventual consistency to manage distributed transactions.

Spring Cloud provides tools to manage configuration, service discovery, circuit breakers, and distributed tracing in a microservices architecture. It simplifies the development and management of cloud-native microservices.

Use REST for synchronous communication and message brokers like Kafka or RabbitMQ for asynchronous communication. REST is ideal when you need an immediate response, while message brokers help decouple services and handle failures gracefully.

Use sagas for distributed transactions or the eventual consistency model. A saga ensures each step in a transaction is followed by compensating actions in case of failure.

Use service discovery tools like Eureka (from Netflix) or Consul. Service instances register themselves, and other services can discover them by querying the registry.

Implement retry logic using libraries like Resilience4j or Spring's RetryTemplate. Combine it with circuit breakers to prevent retrying if the service is down for an extended time.

Implement API versioning using URI paths (e.g., /v1/orders), headers, or query,parameters.

Use horizontal scaling by deploying services across multiple instances and an API Gateway to load balance requests. Use cloud services like AWS or Kubernetes for auto-scaling.

Use mutual TLS (mTLS) for secure communication. Also, implement OAuth 2.0 and JWT tokens for authorization and authentication.

Use message brokers like Kafka, RabbitMQ, or AWS SQS to send messages asynchronously. This ensures that the sender continues without waiting for a response.

Use database-per-service pattern for strong service boundaries and avoid direct database communication. Use event-driven architecture to ensure data consistency across microservices.

Use unit tests with mocks for isolated testing. For inter-service communication, use contract testing (e.g., using Pact). Finally, use integration tests to ensure all services work together.

Implement a circuit breaker using libraries like Resilience4j. If Service B fails, the circuit breaker trips and prevents further requests, returning fallback responses until it recovers.

Use distributed tracing tools like Zipkin or Jaeger to trace requests across services. Implement correlation IDs to track a request throughout the system and use centralized logging (e.g., ELK stack) for logs.

Use event-driven architecture with event sourcing. Microservices publish events when data changes, and other services subscribe to these events to stay updated.

Implement rate limiting using API Gateway tools (like Kong or Spring Cloud Gateway) or libraries like Bucket4j to restrict the number of requests from a single user or client.

Use database migration tools like Flyway or Liquibase. Apply schema changes gradually in backward-compatible ways, supporting both old and new versions.

Use Spring Cloud Config or Consul for centralized configuration management. Store configuration data in a version-controlled repository and refresh configurations dynamically.

Use an API Gateway or service mesh like Istio to implement load balancing. You can also use round-robin or least connections algorithms for distributing requests.

Use event-driven architecture with message brokers to propagate changes. Services should subscribe to events and update themselves asynchronously.

Implement circuit breakers, retry mechanisms, and fallbacks using Resilience4j. Design the system with redundancy and use auto-scaling to recover from high loads.

Use circuit breakers and timeouts to avoid cascading failures. Also, design microservices to be loosely coupled, meaning each service can function independently when another is down.

Use blue-green deployments or canary deployments to gradually shift traffic to the new version while monitoring for any issues.

Use Kubernetes or cloud platforms like AWS to scale services dynamically based on CPU, memory, or custom metrics.

Use containerization with Docker and orchestration with Kubernetes. Automate the deployment process using CI/CD pipelines with tools like Jenkins or GitLab CI.

Extract shared logic into libraries or SDKs and manage them via Maven or Gradle. Ensure services are not tightly coupled by libraries to maintain loose coupling.

Use OAuth 2.0 or JWT for inter-service authorization. Validate JWT tokens in each service and ensure role-based access control (RBAC).

Use prometheus and Grafana for performance monitoring. Implement distributed tracing with Jaeger or Zipkin to trace request flows.

Use compensating transactions or implement Sagas to roll back changes. Alternatively, follow an eventual consistency,approach.