Cloud Native Architecture
Cloud native architecture designs systems around containers, microservices, service meshes, declarative APIs, and immutable infrastructure. It optimizes for automation, resilience, and rapid change by treating the platform's orchestration and observability capabilities as first-class design inputs.
itCloud native tools and technologies | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Cloud Native Architecture
Cloud native architecture is the practice of arranging software so it can change repeatedly without turning every release into a small expedition. It is not a membership card issued by a particular cloud, cluster, or acronym. The point is repeatable delivery, bounded failure, and enough evidence to know whether users are getting the result they came for.
The first useful idea is the boundary: a line around code, data, and responsibility. A boundary is worthwhile when something must change, scale, fail, or be trusted independently. Otherwise it is mostly a new network call wearing a management hat. A modular monolith can be cloud native in the ways that matter if its delivery, recovery, and observability are disciplined.
The second idea is desired state. Instead of personally coaxing every running instance into shape, you record the result you want and let a controller compare it with reality. This makes drift visible and replacement repeatable. It does not make business logic wise, nor does it stop a bad declaration from being applied with great consistency, which is an impressively efficient way to preserve a mistake.
Third, treat remote work as uncertain. A timeout can arrive after the other side completed the request; a retry can repeat the business effect; an event can arrive twice or late. Give calls deadlines, make repeatable operations safe, and decide what happens when a dependency is absent. Failure domain means the portion of the system one failure can disturb. Keep it smaller than the whole operation when the requirement warrants the cost.
An immutable artifact also matters. Build it once, identify it, promote it, and replace running versions rather than repairing them in place. Then follow the user journey with metrics, logs, and traces. A healthy machine is not the same thing as a successful order, message, or page. Computers find that distinction endlessly fascinating.
Read the Intro for the full architecture and failure model. Use Slides to see the relationships between boundaries, control loops, and delivery. Keep the Cheatsheet nearby during a design review. The exercise turns the ideas into an order-intake design, and the Reference tab leads from the foundations into the official material.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://github.com/cncf/toc/blob/main/DEFINITION.md
Supports
- Cloud native practices apply to public, private, and hybrid computing environments
- Target qualities include loose coupling, security, resilience, manageability, sustainability, and observability
- Containers, service meshes, multi-tenancy, microservices, immutable infrastructure, serverless, and declarative APIs are examples rather than mandatory ingredients
- Repeatable automation supports frequent and predictable change with separation of concerns
- https://12factor.net/
Supports
- One codebase can have many deploys
- Dependencies should be declared and isolated
- Configuration is separate from code
- Build, release, and run are distinct stages
- Application processes should be stateless and disposable
- Logs are treated as event streams
- https://kubernetes.io/docs/concepts/architecture/
Supports
- Kubernetes separates control-plane components from worker-node components
- Controllers implement control loops over declared and observed state
- https://kubernetes.io/docs/concepts/architecture/controller/
Supports
- A controller tracks Kubernetes resources and works to move current state toward desired state
- Reconciliation is a continuing loop rather than a one-time script
- https://kubernetes.io/docs/concepts/workloads/controllers/deployment/
Supports
- A Deployment provides declarative updates for Pods and ReplicaSets
- The Deployment controller changes actual state toward desired state at a controlled rate
- https://kubernetes.io/docs/concepts/architecture/self-healing/
Supports
- Kubernetes can restart containers and replace workload replicas
- Services stop routing to failed Pods
- Application errors and some storage failures can require action outside platform self-healing
- https://opengitops.dev/
Supports
- GitOps desired state is declarative
- Desired state is versioned and immutable with retained history
- Software agents pull desired state automatically
- Agents continuously reconcile actual state toward desired state
- https://opentelemetry.io/docs/concepts/signals/
Supports
- OpenTelemetry signals include traces, metrics, logs, and baggage
- Signals provide complementary views of system behavior
- https://opentelemetry.io/docs/concepts/signals/traces/
Supports
- A distributed trace records the path of a request through an application
- Spans represent units of work and form the trace
- https://csrc.nist.gov/pubs/sp/800/204/final
Supports
- Microservices can support independent development, deployment, platform optimization, and component scaling
- Microservices communicate through APIs and require supporting security and communication capabilities
- Supporting concerns include authentication, access management, discovery, secure communication, monitoring, resilience, load balancing, throttling, and session handling
- API gateways and service meshes can package some supporting capabilities
- https://www.docker.com/blog/docker-now-in-public-beta/
Supports
- Docker entered public beta in 2013, making application containers a broadly available developer workflow.
- https://cloudplatform.googleblog.com/2014/06/Introducing-Kubernetes-Open-Source-Container-Manager.html
Supports
- Kubernetes was announced as an open-source container manager in 2014.
- https://www.cncf.io/news/2015/07/21/techcrunch-as-kubernetes-hits-1-0-google-donates-technology-to-newly-formed-cloud-native-computing-foundation/
Supports
- Kubernetes reached 1.0 and was donated to the newly formed CNCF in 2015.
- https://www.cncf.io/blog/2016/05/09/prometheus-joins-cloud-native-computing-foundation/
Supports
- Prometheus joined CNCF in 2016, strengthening the cloud native observability ecosystem.
- https://www.cncf.io/blog/2018/03/06/kubernetes-becomes-first-cncf-project-to-graduate/
Supports
- Kubernetes became the first CNCF graduated project in 2018.
- https://opentelemetry.io/blog/2019/05/21/introducing-opentelemetry/
Supports
- OpenTelemetry was introduced in 2019 through the merger of OpenCensus and OpenTracing.
- https://kubernetes.io/blog/2020/12/02/dont-panic-kubernetes-and-docker/
Supports
- Kubernetes announced dockershim deprecation in 2020 and explained the transition to CRI-compatible runtimes.
- https://kubernetes.io/blog/2022/05/03/kubernetes-1-24-release-announcement/
Supports
- Kubernetes 1.24 removed dockershim in 2022.
- https://www.cncf.io/projects/kubernetes/
Supports
- The Landscape entries use the projects and managed platforms that implement the control loops, delivery paths, policy, and observability boundaries discussed in this course.
