Microservice architecture
Microservice architecture is a software architectural style that organizes an application as independently deployable services with focused responsibilities that communicate through defined interfaces.
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
An architectural style that structures an application as a collection of small, independently deployable services with distinct boundaries.
- How it is used
- Uses independently deployable services to manage application growth while building a working distributed application.
- How deep it goes
- Defines service boundaries and tradeoffs, then develops a local-to-production workflow; it favors necessary tooling over exhaustive distributed-systems theory.
- Examples
- Builds a video-streaming application with a gateway and streaming, storage, and upload services.
- What you can do after
- Build it from scratch: run services locally, test their collaboration, and deploy them through a Kubernetes-based production workflow.
Google Anthos in Action
A microservices architecture structures an application as independently deployable services that communicate over a network.
- How it is used
- Uses independently deployable services to modernize applications, accelerate delivery, and support scalable distributed operations.
- How deep it goes
- Explains modularity, deployment benefits, operational drawbacks, service-mesh capabilities, and incremental migration, but not service implementation code.
- Examples
- Uses Anthos deployments, containerized Linux or Windows applications, Migrate for Anthos, VM migration, mutual TLS, and service-level objectives.
- What you can do after
- Operate/configure microservice applications with automated deployment, service-mesh security, dependency management, and performance observability.
Read how Google Anthos in Action explains microservice architecture →
gRPC Microservices in Go
Microservice architecture is an architectural style that structures an application as loosely coupled, independently deployable, and independently scalable services.
- How it is used
- Frames when to decompose an application into independently deployable business capabilities rather than retain a monolith.
- How deep it goes
- Defines service characteristics and selection criteria, then sketches communication and consistency challenges without detailing their implementation here.
- Examples
- Uses product, cart, checkout, payment, and shipping services, including checkout calls through generated gRPC stubs.
- What you can do after
- Evaluate/understand it: assess whether business boundaries and scaling or release problems justify decomposition, then identify interservice calls needing fault tolerance.
Read how gRPC Microservices in Go explains microservice architecture →
Cloud Observability in Action
A microservices application is an application composed of independently deployable services that communicate over interfaces.
- How it is used
- Frames independently deployable services as components of cloud-native applications and as units for following distributed requests.
- How deep it goes
- Defines service independence and interfaces, then follows concrete request paths without detailing service implementation internals.
- Examples
- Uses Sock Shop, an e-commerce checkout workflow, and a frontend-to-service-A-to-service-B request graph.
- What you can do after
- Operate/configure a demonstrative microservices application on Kubernetes and inspect its logs, metrics, and distributed traces.
Read how Cloud Observability in Action explains microservice architecture →
Think Like a CTO
A microservices architecture structures a system as independently deployable services that are narrowly scoped and communicate through defined interfaces.
- How it is used
- Frames an enterprise architecture decision around independently changing components and the risks of a tightly coupled monolith.
- How deep it goes
- Defines service scope, communication, and independence, then offers a monolith checklist rather than implementation instructions.
- Examples
- Illustrates risk through a tightly coupled library upgrade and incremental migration through refactoring parts of a legacy system.
- What you can do after
- Evaluate/understand it by checking monolith characteristics and identifying legacy areas that could be extracted without a complete rewrite.
Read how Think Like a CTO explains microservice architecture →
AI Agents in Action, Second Edition
A microservices architecture is a software architecture in which an application is composed of independently deployable services with focused responsibilities.
- How it is used
- Deploys focused agent capabilities as services that applications or other agents consume through APIs, MCP, or A2A.
- How deep it goes
- Defines service boundaries and container deployment, but defers Kubernetes and other cloud-environment deployment details.
- Examples
- Uses a browser frontend consuming multiple containerized agents as API tools or MCP servers.
- What you can do after
- Apply it via Docker by packaging focused agents for independent use, replacement, scaling, and versioning.
Read how AI Agents in Action, Second Edition explains microservice architecture →
Go in Practice, Second Edition
A microservice architecture is an application architecture composed of independently deployable services that communicate over a network.
- How it is used
- Deploys cloud applications as independently scalable and failure-resilient services with focused responsibilities.
- How deep it goes
- Defines service boundaries and communication trade-offs, then demonstrates Kafka-based message consumption without detailing deployment mechanics.
- Examples
- Uses a media transcoding workflow and a Go Kafka consumer that reads media batches for processing or delegation.
- What you can do after
- Build it from scratch by separating focused Go services, routing work through queues, and selecting communication methods for performance.
Read how Go in Practice, Second Edition explains microservice architecture →
Software Security for Developers
A software architecture that decomposes an application into independently deployable services organized around business capabilities.
- How it is used
- Organizes applications around independently deployable business capabilities and frames the security of their call chains.
- How deep it goes
- Defines service boundaries and illustrates call-graph complexity, then focuses on communication security rather than deployment mechanics.
- Examples
- Uses an online product page with book-details, pricing, ratings, search, and delivery-estimation services.
- What you can do after
- Evaluate service boundaries and identify authentication and communication risks across a service-to-service call graph.
Read how Software Security for Developers explains microservice architecture →
Kubernetes for Developers
Microservices is an architectural pattern that structures an application as multiple independently maintained services.
- How it is used
- Structures applications as cooperating services when separate scaling, teams, languages, or dependency environments provide practical value.
- 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 you can do after
- Evaluate whether separate services justify their scaling and team benefits despite added debugging, testing, and request-tracing complexity.
Read how Kubernetes for Developers explains microservice architecture →
Kubernetes in Action, Second Edition
A microservice architecture structures an application as multiple independently deployable services that collaborate through defined interfaces.
- How it is used
- Frames Kubernetes as a way to automate the management of independently developed and deployed application services.
- How deep it goes
- Explains team boundaries, release cycles, dependencies, communication, and management challenges, but stops short of detailed service design.
- Examples
- Uses the Kiada application, Docker execution, Kubernetes deployment, and a monolith-versus-microservices comparison.
- What you can do after
- Evaluate when separate services improve team ownership and scaling while recognizing their environment, communication, and management costs.
Read how Kubernetes in Action, Second Edition explains microservice architecture →
Kafka for Architects
Microservices architecture is an architectural style composed of independently deployable services organized around separate capabilities.
- How it is used
- Organizes independently deployable services around separate capabilities and uses Kafka for decoupled event communication.
- How deep it goes
- Explains service roles, Kafka integration, frameworks, and trade-offs, but stops short of low-level client implementation.
- Examples
- Uses customer profiles, billing events, clickstream analytics, fraud scoring, IoT telemetry, and operational alerting.
- What you can do after
- Builds Kafka-integrated producer and consumer services with Spring-Kafka, Micronaut-Kafka, or lower-level clients.
Read how Kafka for Architects explains microservice architecture →
Python Concurrency with asyncio
Microservice architecture is a system design style that structures an application as a set of independently deployable services communicating over defined interfaces.
- How it is used
- Uses independently deployable services to separate application responsibilities, scale uneven workloads, and support team ownership.
- How deep it goes
- Explains principles, tradeoffs, scaling, team independence, asynchronous calls, and resilience patterns, then applies them to e-commerce services.
- Examples
- Uses e-commerce product, user, order, and backend-for-frontend services to demonstrate decomposition, scaling, communication, and failure handling.
- What you can do after
- Apply the architecture to an e-commerce system using independent services, asynchronous calls, retries, and a circuit breaker.
Read how Python Concurrency with asyncio explains microservice architecture →
BDD in Action, Second Edition
Microservice architecture is an application architecture in which independently deployable services implement separate business capabilities and communicate through defined interfaces.
- How it is used
- Deploys microservice boundaries as the basis for API-level acceptance tests and service-interaction scenarios.
- How deep it goes
- Traces a multi-service registration flow through endpoints, databases, tokens, events, and a message broker.
- Examples
- Uses Frequent Flyer registration, email confirmation, authentication, account lookup, and an executable acceptance scenario.
- What you can do after
- Apply it via RESTAssured and JSONPath to automate acceptance scenarios through APIs rather than the user interface.
Read how BDD in Action, Second Edition explains microservice architecture →
Authorization in Action
Microservices is an architectural pattern in which an application is composed of independently deployable services that communicate over a network.
- How it is used
- Uses independently deployed services and networked APIs to support organizational and technical integration.
- How deep it goes
- Explains service decomposition and compares gateway, service-mesh, and per-service proxy enforcement, without detailing deployment implementation.
- Examples
- Uses ACME’s decomposed collaboration, HR, and Finance systems and a cross-service project-report request.
- What you can do after
- Evaluate where authorization enforcement should sit across gateways, service meshes, and critical service APIs.
Read how Authorization in Action explains microservice architecture →
Related concepts
- monolithic architecturealternative to · Monolithic architecture is a software architecture in which an application's major functionality is organized and deployed as a single integrated unit.
- distributed systemkind of · A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
- autonomyproduces · Autonomy is the capacity or degree to make decisions and act independently within a defined responsibility or set of limits.
- servicehas part · A service is a capability or activity provided by an entity to meet the needs of users or other components.
- fast flowproduces · Fast flow is the rapid, sustainable movement of work through a value stream, supported by minimal delays and timely feedback.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.