Comment les composants communiquent-ils dans un système (APIs) ?

Question

Accepted Answer

Dans un système, les composants (services, clients) communiquent via des **APIs** et divers protocoles — synchrones (REST, gRPC) et asynchrones (messaging/files d'attente). Comprendre comment les composants communiquent est fondamental pour concevoir des systèmes composés de plusieurs parties.

## Communication synchrone (requête/réponse)

```text
The caller WAITS for a response (blocking):
  REST (HTTP) → most common; resources over HTTP (JSON) → simple, ubiquitous, web-friendly
  gRPC → high-performance RPC (binary, HTTP/2) → fast, typed; good for internal services
  GraphQL → flexible queries (client requests exactly what it needs)
→ for: direct request/response where the caller needs an answer now
```

## Communication asynchrone (messaging)

```text
The caller does NOT wait (decoupled, non-blocking):
  MESSAGE QUEUES (RabbitMQ, SQS) → send a message; a consumer processes it later
  EVENT STREAMING (Kafka) → publish events; consumers react
  PUB/SUB → broadcast events to subscribers
→ for: decoupling, background work, handling spikes, event-driven systems
  ✓ resilience (queue buffers), scalability, decoupling  ✗ more complexity, eventual consistency
```

## Choix et considérations

```text
SYNC → when the caller needs an immediate response; simpler request/response
ASYNC → when decoupling, resilience, or background processing matters (don't block)
→ Also: API design (clear contracts), versioning, error handling, timeouts/retries,
  authentication, rate limiting → robust communication between components
```

## Pourquoi c'est important

Comprendre comment les composants communiquent via les APIs est fondamental car **les systèmes sont composés de plusieurs parties qui doivent communiquer**, donc comprendre la communication est essentiel pour les concevoir.

Les systèmes se composent de services et de clients qui interagissent, et la manière dont ils communiquent est un aspect fondamental de la conception de systèmes.

Comprendre la **communication synchrone** (requête/réponse où l'appelant attend) — **REST** (l'approche HTTP/JSON omniprésente), **gRPC** (RPC haute performance pour les services internes), et GraphQL (requêtes flexibles) — couvre les façons courantes dont les composants font des appels directs en attendant une réponse.

Comprendre la **communication asynchrone** (découplée, non-bloquante) — **files d'attente de messages** (envoi de messages pour un traitement ultérieur), **event streaming** (Kafka), et pub/sub — est tout aussi important, car elle permet le **découplage, la résilience (files d'attente amortissant la charge), la scalabilité, et les systèmes basés sur les événements**, au détriment d'une plus grande complexité et de la cohérence finale.

Comprendre la **distinction sync vs async et quand utiliser chacune** — synchrone quand l'appelant a besoin d'une réponse immédiate, asynchrone quand le découplage, la résilience, ou le traitement en arrière-plan importe — est une considération clé de conception qui affecte significativement les caractéristiques d'un système.

Comprendre les considérations supplémentaires (contrats d'API clairs, versioning, gestion des erreurs, timeouts/retries, authentification, rate limiting) reflète la conception d'une communication robuste.

Puisque les systèmes sont composés de parties communicantes et la manière dont elles communiquent (sync vs async, les protocoles, et les considérations de conception) façonne fondamentalement le système, et puisque comprendre la communication entre composants est essentiel pour concevoir des systèmes multi-composants, comprendre comment les composants communiquent via les APIs est une connaissance système-design essentielle et fondamentale — fondamentale pour concevoir des systèmes composés de plusieurs parties interactives, couvrant la communication synchrone et asynchrone qui connecte les composants, et centrale pour architecturer les systèmes distribués et basés sur les services courants aujourd'hui.