liveBook · Manning

Microservice architecture

As explained in Kubernetes for Developers

Microservices is an architectural pattern that structures an application as multiple independently maintained services.

Microservice architecture splits an application into several internal services. Each service performs a separate task and communicates with other services through remote procedure calls, typically HTTP requests. This contrasts with a monolith, where the complete program logic runs in one service or container. section 6.4.2

Splitting an application into services can provide:

  • Independent scaling, so services handling different workloads can be scaled separately. section 6.4.2
  • Independent development by separate teams, with the option to choose different programming languages for different services. section 6.4.2
  • Dependency isolation when services run in containers, allowing different operating systems, package managers, libraries, or language environments on one host. section 1.1.1
  • More difficult debugging and integration testing, because requests cross more components and require tracing. section 6.4.2

Frontend with an internal service

A frontend can serve two HTTP paths while communicating with an internal service. Alternatively, the paths can be served by separate services, making their scaling and maintenance boundaries explicit. section 6.4.2

Figure 6.5 Two paths being served by separate services
06-05

Compare two paths served by separate services to see how service boundaries change deployment structure. section 6.4.2

How Kubernetes for Developers covers it

How deep it goes
Explains service boundaries, HTTP communication, benefits, and operational drawbacks without prescribing a universal architecture choice.
Examples
Uses frontends communicating with internal services, separate services serving paths, and containers hosting different languages and dependencies.
What it assumes
Assumes a basic application and service model, while explaining monoliths, HTTP calls, and container dependency isolation.
What you can do after
Evaluate whether separate services justify their scaling and team benefits despite added debugging, testing, and request-tracing complexity.
How it connects
Connects microservices with monoliths, remote procedure calls, containers, dependency isolation, independent scaling, debugging, and integration testing.

Also explained in

Compare how 14 books explain microservice architecture →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Kubernetes for Developers. The section links point to the parts of the book it draws on.