liveBook · Manning

Cloud-native architecture

As explained in Platform Engineering on Kubernetes

A cloud-native application is software designed to run using cloud-oriented infrastructure and operational practices, commonly with independently deployable services.

Cloud-native architecture treats an application as services that can evolve and scale independently on cloud-oriented infrastructure. That flexibility comes with distributed-system costs: network latency, partial failures, and data that may not be immediately consistent. A small but complete “walking skeleton” makes those trade-offs testable before more features are added. section 1.4.2 section 2.1 section 1.4

Start with a Conference application

A frontend routes user requests to backend services. Implementing a Call for Proposals use case first establishes building blocks for later features, such as sponsor management or speaker profiles. Deploying the services to Kubernetes then makes their configuration, data flows, and scaling behavior visible. section 1.4.1

Figure 1.18 Conference application services. The end user interacts with the frontend that routes requests to all the backend services.

The service diagram shows the frontend-to-backend arrangement behind the Conference application. section 1.4.1

The service boundaries change both development and operations:

  • Teams can change services without sharing one codebase and one continuous-integration pipeline; each service can also be scaled for its own load. section 1.4.2
  • A failed service should degrade useful functionality rather than take down the whole application. Service code must handle downstream failures; Kubernetes service discovery alone does not make it resilient. section 2.4
  • Distributed state needs attention: services can hold different views of data, while their infrastructure requirements affect how they scale. section 2.4

Use the walking skeleton to try integrations and delivery practices without repeatedly changing an application just for experimentation. A Kubernetes cluster is required to run this example; deciding whether it belongs locally or elsewhere is itself an operational choice. Changing service configurations and observing the resulting behavior provides feedback for both application design and the platform that supports teams. section 1.4 section 2.1 section 2.4 section 1.4.3

How Platform Engineering on Kubernetes covers it

How deep it goes
Develops the pattern through a multi-service example, monolith comparison, and runtime experiments; treats the challenge list as non-exhaustive.
Examples
Follows a Conference application with frontend and backend services, a Call for Proposals use case, and Kubernetes configuration changes.
What it assumes
Requires a Kubernetes cluster for hands-on operation while introducing distributed-system challenges through a controllable multi-service example.
What you can do after
Operate/configure it by deploying services to Kubernetes, inspecting data flows and scaling, and changing configurations to observe failure behavior.
How it connects
Links distributed systems, Kubernetes, service discovery, resilience, data consistency, and independent service scaling.

Also explained in

Compare how 6 books explain cloud-native architecture →

Related concepts

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