liveBook · Manning

Component architecture

As explained in Microservices Patterns, Second Edition

A component architecture organizes an application into software components and defines their structural relationships.

Component architecture organizes an application into components and defines their structural relationships. For a large application developed by many teams, multiple components can limit the scope of changes and let teams evolve, test, and deploy parts of the system independently. section 5.3.4 section 5.7

The benefits depend on the boundaries. Private technology-stack elements can be upgraded within one component, while shared elements such as a message broker require coordination. Even an upgrade affecting every component can be scheduled as smaller, incremental changes. The trade-off is repeated work: a library used by every component must be upgraded separately in each one. section 5.3.4

Figure 5.12 A multi-component architecture significantly improves an application’s evolvability. Upgrading the private elements of a component’s technology stack affects just that component and its team or teams. Typically, only upgrades of shared technology stack elements require many teams to collaborate.
evolvability multi component

Compare the scope of upgrades to private and shared technology-stack elements. section 5.3.4

Component boundaries influence several delivery capabilities:

  • Testing: independently testable components can reduce the resources needed for local development. Incremental builds and loose build-time coupling also limit which projects must be retested. section 5.4.4 section 5.4.5
  • Deployment: smaller components may start faster, and separate deployment pipelines can run in parallel rather than competing for one pipeline. section 5.5.2
  • Observability: component-level telemetry can help make a large system observable, but instrumentation and infrastructure are still needed to collect and analyze it. section 5.6.2

Keep clients away from changing implementations

An order-management project can depend on a stable customer-management API project instead of the customer-management implementation project. A change to the implementation then need not trigger retesting of the order-management implementation. section 5.4.4

A microservice architecture is one multi-component option: services can evolve one at a time and be tested in isolation. Those gains require discipline to keep service dependencies loosely coupled. For local work, splitting an application helps only if developers can run the component they are changing without also running many others. Weigh that benefit against the cost of maintaining and upgrading multiple components; a small application may be practical to run and test as a whole. section 7.4.1 section 5.4.5 section 5.3.4

How Microservices Patterns, Second Edition covers it

How deep it goes
Explains operational benefits and upgrade trade-offs, without specifying a complete component design procedure.
Examples
Illustrates a stable customer-management API dependency and coordination around a shared message broker.
What you can do after
Evaluate component boundaries against upgrade scope, local testing needs, and deployment throughput.
How it connects
Connects component architecture to build-time coupling, local testing, deployment pipelines, observability, and microservices.

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Microservices Patterns, Second Edition. The section links point to the parts of the book it draws on.