Microservices Interview Questions and Answers

Differentiate monolithic, service oriented architecture, and microservices by contrasting single code base and shared database with microservices' fine-grained, rest-based services each with dedicated databases.

Explore alternatives to monolithic applications, including component-based libraries, service oriented architecture, and microservices, with focus on independent services, api communication, asynchronous messaging, and diverse technology stacks.

Understand how microservices relate to business goals by using cloud pay-as-you-go models and managed Kubernetes with AWS, Azure, and Google Cloud Platform to enable agile, faster outsourcing while protecting IP.

Draw a simple architectural diagram of a microservices system on a whiteboard, showing UI service, API gateway, identity provider authentication, per-service databases, and asynchronous event bus.

Explore ways to build microservices, including one service per virtual server, containerization with Docker and Kubernetes, and serverless options on cloud providers like AWS, with Spring Boot.

Idempotence is a concept, not a design pattern, ensuring the same output for the same input to improve microservice resiliency. Track messages with a unique identifier to prevent duplicates.

discover how api composition lets you fetch data from multiple microservices by querying each service, joining results in memory, and returning a unified response via an api composer microservice.

Apply the strangler pattern to migrate legacy monoliths to microservices by incrementally replacing functionality while the system stays live.

Explain how independent microservices communicate, comparing synchronous point-to-point API calls with event-based messaging via event streams like Apache Kafka and message queues such as ActiveMQ or RabbitMQ.

Learn the two-phase commit pattern, with prepare and commit phases coordinated by a transaction ID, where microservices prepare, then commit, and failures trigger abort.

Explore the saga pattern as an asynchronous approach to distributed transactions, where each microservice manages its own transaction. Learn about choreography and orchestration patterns for managing workflows and rollbacks.

Explain the choreography pattern for distributed transactions, where an order microservice emits an order created event and a customer microservice updates funds with eventual compensation if needed.

Orchestrate distributed transactions with a centralized orchestrator that guides workflow execution and coordinates compensating actions via events among order, inventory, and payment services.

Apply the circuit breaker pattern to api calls by placing a proxy breaker between client and supplier, enforcing open, half-open, and closed states with a three-failure threshold and backoff retries.

OAuth enables open authentication by using a trusted provider as the source of truth. It uses scopes and claims to control access, allowing a single token to authorize multiple microservices.

Explain how client certificates authenticate API users using a public key and private key during a TLS handshake, with certificates issued by a trusted authority to grant access.

Explore four security testing approaches for microservices: dust (dynamic application security testing), sast (static), yast (interactive), and rasp (runtime application security protocol) with real-time checks and region-based ip control.

Explore how authentication and authorization secure microservices using OAuth 2 and JWT tokens, including scopes, authorization servers, and token validation via an API gateway.

Explain testing strategies for microservices, covering unit, integration, contract, and end-to-end tests. Emphasize automating tests for both individual services and their integrated system.

Master semantic monitoring by validating end-to-end business transactions across microservices through functional testing. Compare service layer monitoring, health endpoints, and telemetry to ensure the whole system performs as expected.

Docker packages an application and its dependencies into a Docker image, runs Docker containers, and provides networking for container communication.

Deploy Docker containers locally with Docker Desktop for development, or run them on serverless services like AWS Fargate; or use Kubernetes for orchestration with networking, monitoring, logging, and access control.

Explain how microservices locate each other through a centralized service registry, avoiding hardcoded ip or dns, and contrast client-side lookups with server-side routing via a load balancer.

Explore the sidecar pattern for resiliency and cleaner design by isolating auxiliary functions, like logging and configuration, in a separate process shared across microservices.

Explore the service mesh pattern as a dedicated infrastructure layer that manages service-to-service communication with traffic routing, security, observability, and resilience via sidecar proxies, without changing application code.

Explain the transactional outbox pattern: write events to an outbox table within a transaction with read committed, then a relay service publishes only committed, ordered events to the message broker.

Explore how microservices avoid local state by offloading data to a shared Redis cache, enabling resilience as containers scale out and terminate in cloud environments.

Explore the scaling cube: scale resources with auto scaling on the x axis, scale microservices independently on the y axis, and partition data by region on the z axis to handle load.