System Design - Microservices Architecture & API Design Flashcards

Question 1

What is the core principle behind microservices architecture?

Accepted Answer

Microservices architecture structures an application as a collection of loosely coupled, independently deployable services, each responsible for a specific business capability or bounded context.

Question 2

Explain the Single Responsibility Principle (SRP) in the context of microservices.

Accepted Answer

SRP dictates that each microservice should have one and only one reason to change, meaning it should be responsible for a single, well-defined business capability. This promotes modularity and maintainability.

Question 3

What does 'independent deployment' mean in microservices?

Accepted Answer

Independent deployment means that each microservice can be developed, tested, and deployed without affecting or requiring redeployment of other services in the system. This enables faster release cycles and reduces coordination overhead.

Question 4

What problem does Service Discovery solve in a microservices architecture?

Accepted Answer

Service discovery allows client applications and other services to find the network location (IP address and port) of a service instance. This is crucial in dynamic environments where service instances scale up/down or change locations frequently.

Question 5

Differentiate between Client-side and Server-side Service Discovery.

Accepted Answer

In **Client-side discovery**, the client queries a service registry (e.g., `Eureka`, `Consul`) to get available service instances and then directly calls one. In **Server-side discovery**, the client makes a request to a router/load balancer (e.g., AWS ELB, `Nginx`) which queries the service registry and forwards the request to an available service instance.

Question 6

What is an API Gateway and what are its primary functions?

Accepted Answer

An API Gateway is a single entry point for all clients into a microservices system. Its primary functions include request routing, authentication/authorization, rate limiting, load balancing, caching, and protocol translation.

Question 7

List common inter-service communication patterns.

Accepted Answer

Common patterns include synchronous HTTP/REST, synchronous gRPC, and asynchronous message-based communication using message queues (e.g., `Kafka`, `RabbitMQ`) or event streams.

Question 8

What are the key characteristics of RESTful API design?

Accepted Answer

RESTful APIs are stateless, use standard HTTP methods (GET, POST, PUT, DELETE), operate on resources identified by URIs, and often return data in JSON or XML format. They emphasize a client-server architecture and uniform interface.

Question 9

When might gRPC be preferred over REST for inter-service communication?

Accepted Answer

gRPC is often preferred for:
*   High-performance, low-latency communication.
*   Services requiring streaming (bidirectional, client, server).
*   Polyglot environments due to its language-agnostic Protocol Buffers.
*   Internal microservice communication where browser compatibility isn't a concern.

Question 10

Explain the role of Protocol Buffers in gRPC.

Accepted Answer

Protocol Buffers (`protobuf`) are a language-agnostic, platform-neutral, extensible mechanism for serializing structured data. In gRPC, they define the service interface and message structures, allowing efficient data exchange and code generation for various languages.

Question 11

How do Message Queues facilitate asynchronous communication in microservices?

Accepted Answer

Message queues decouple services by allowing a producer service to send a message to a queue without waiting for an immediate response. A consumer service can then process the message at its own pace, improving resilience, scalability, and fault tolerance.

Question 12

What is the Saga pattern in distributed transactions?

Accepted Answer

The Saga pattern is a way to manage distributed transactions by breaking them down into a sequence of local transactions, where each local transaction updates data within a single service. If a step fails, compensating transactions are executed to undo previous changes.

Question 13

Differentiate between Choreography and Orchestration in the Saga pattern.

Accepted Answer

In **Choreography**, each service publishes events and reacts to events from other services, without a central coordinator. In **Orchestration**, a central orchestrator (a dedicated service) coordinates the execution of local transactions across multiple services, telling each service what to do.

Question 14

What does 'Eventual Consistency' mean in a distributed system?

Accepted Answer

Eventual consistency is a consistency model where, given enough time, all replicas of a data item will converge to the same value. It means that after an update, reads may return stale data for a period, but eventually, all reads will return the latest updated value.

Question 15

Why is idempotency important for API design, especially in distributed systems?

Accepted Answer

An idempotent operation can be called multiple times without causing different results beyond the first call. It's crucial for reliability in distributed systems, as it allows clients to safely retry requests (e.g., due to network errors) without unintended side effects like duplicate resource creation.

Question 16

Describe common strategies for API versioning.

Accepted Answer

Common strategies include:
*   **URI Versioning:** `api.example.com/v1/resources`
*   **Header Versioning:** Using a custom header like `X-API-Version` or `Accept` header with a media type.
*   **Query Parameter Versioning:** `api.example.com/resources?version=1`
URI and Header versioning are generally preferred.

Question 17

What is HATEOAS and why is it considered a principle of mature REST APIs?

Accepted Answer

HATEOAS (Hypermedia as the Engine of Application State) means that a client interacts with a REST API entirely through hypermedia controls (links) provided dynamically by the server. It makes APIs self-discoverable and less coupled to specific URI structures, improving evolvability.

Question 18

Compare and contrast GraphQL with REST.

Accepted Answer

GraphQL is graph-centric, uses a single endpoint, and allows clients to specify exact data needs, avoiding over/under-fetching. REST is resource-centric, uses multiple endpoints, and returns fixed data structures per endpoint. GraphQL offers more client flexibility, while REST is simpler for basic CRUD operations.

Question 19

When would you choose GraphQL over REST for an API?

Accepted Answer

GraphQL is often chosen when:
*   Clients need to fetch data from multiple resources in a single request (reducing round trips).
*   Clients have diverse data requirements (e.g., mobile vs. web clients).
*   Over-fetching or under-fetching data is a significant concern.
*   Rapid prototyping and iteration on client-side data needs are important.

Question 20

What is a Bounded Context in microservices design?

Accepted Answer

A Bounded Context is a central pattern in Domain-Driven Design (DDD) that defines the boundaries within which a particular model (domain model) is consistent and meaningful. In microservices, each service typically corresponds to a single bounded context, ensuring clear responsibilities and preventing model ambiguity.

Question 21

How do you handle shared data or database access in a microservices architecture?

Accepted Answer

Each microservice should own its data and database, avoiding shared databases. If data needs to be shared, it should be done via API calls, events, or data replication (e.g., materialized views) rather than direct database access, to maintain service independence and autonomy.

Question 22

What are the benefits of using an Event-Driven Architecture (EDA) in microservices?

Accepted Answer

EDA promotes loose coupling, improved scalability, and enhanced resilience. Services communicate by producing and consuming events, allowing them to react asynchronously to changes, facilitating complex workflows, and making the system more adaptable to failures.

System Design - Microservices Architecture & API Design

Card Preview

Related Flashcard Sets

Classical Mechanics - Kinematics, Dynamics & Energy Conservation

German B1 - Intermediate Grammar & Conversational Skills

CFA Level 1 - Financial Reporting & Analysis

Stanford CS144 - Introduction to Computer Networks (Advanced)