Hur kommunicerar komponenter i ett system (API:er)?

Question

Accepted Answer

I ett system kommunicerar komponenter (tjänster, klienter) genom **API:er** och olika protokoll — synkron (REST, gRPC) och asynkron (meddelanden/köer). Att förstå hur komponenter kommunicerar är grundläggande för att designa system som består av flera delar.

## Synkron kommunikation (request/response)

```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
```

## Asynkron kommunikation (meddelanden)

```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
```

## Att välja och överväganden

```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
```

## Varför det är viktigt

Att förstå hur komponenter kommunicerar via API:er är grundläggande eftersom **system består av flera delar som måste kommunicera**, så förståelse för kommunikation är väsentlig för att designa dem.

System består av tjänster och klienter som interagerar, och hur de kommunicerar är en grundläggande aspekt av systemdesign.

Att förstå **synkron kommunikation** (request/response där anroparen väntar) — **REST** (det allmänna HTTP/JSON-tillvagagångssättet), **gRPC** (högt prestanda RPC för interna tjänster) och GraphQL (flexibla frågor) — täcker de vanliga sätten som komponenter gör direkta anrop och förväntar sig ett svar.

Att förstå **asynkron kommunikation** (frikopplad, icke-blockerande) — **meddelandeköer** (skicka meddelanden för senare bearbetning), **event streaming** (Kafka) och pub/sub — är lika viktigt, eftersom det möjliggör **frikoppling, motståndskraft (köer buffrar belastning), skalbarhet och event-driven system**, till priset av större komplexitet och slutlig konsekvens.

Att förstå **distinktionen mellan synkron och asynkron och när man använder varje** — synkron när anroparen behöver ett omedelbar svar, asynkron när frikoppling, motståndskraft eller bakgrundsbearbetning är viktig — är en viktig designövervägande som avsevärt påverkar ett systems egenskaper.

Att förstå ytterligare överväganden (tydliga API-kontrakt, versionshantering, felhantering, timeout/försök igen, autentisering, hastighetsbegränsning) återspeglar designen av robust kommunikation.

Eftersom system är sammansatta av kommunicerande delar och hur de kommunicerar (synkron kontra asynkron, protokollen och designövervägandena) fundamentalt formar systemet, och eftersom förståelse för komponentkommunikation är väsentlig för att designa system med flera komponenter, är förståelse för hur komponenter kommunicerar via API:er väsentlig, grundläggande kunskaper om systemdesign — grundläggande för att designa system som består av flera interagerande delar, täcker den synkrona och asynkrona kommunikation som förbinder komponenter, och är central för arkitekturering av de distribuerade, tjänstebaserade system som är vanliga idag.