Cloud Native Fundamentals
Cloud native fundamentals covers the principles and technologies — containers, orchestration, microservices, CI/CD, and observability — that enable organizations to build and run scalable applications on modern cloud infrastructure with speed and resilience.
itCloud native tools and technologies | OpenSkills.info
Intro
Cloud Native Fundamentals
Cloud native is a way to build and operate workloads for change at scale. It combines architecture, automation, and operating practices. The goal is a system that teams can change predictably while the system remains secure, resilient, manageable, sustainable, and observable.
The Cloud Native Computing Foundation, or CNCF, does not tie cloud native to one product. Its definition covers public, private, and hybrid cloud environments. A workload can be cloud native without running in a public cloud. A workload can also run in a public cloud without being cloud native.
Start with the operating model
Traditional operations often center on long-lived machines. An operator configures a machine, repairs it in place, and records the changes. Cloud native operations shift attention toward declared state and replaceable units.
You describe the result you want. Software controllers compare that desired state with the actual state. They act to reduce the difference. If an instance fails, the platform can replace it. If demand changes, the platform can adjust capacity. If you release a new version, the platform can roll the change out in controlled steps.
This reconciliation loop is the central mental model:
declare desired state
|
v
observe actual state
|
v
compare and act
|
+-------- repeat --------+
Automation is not a one-time script around a manual process. The control loop keeps checking the system after the first change.
Recognize the common building blocks
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
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 definition across public, private, and hybrid environments
- Loose coupling and secure, resilient, manageable, sustainable, observable operation
- Typical technologies and the role of automation in frequent, predictable change
- https://glossary.cncf.io/
Supports
- Vendor-neutral vocabulary and navigation among cloud native concepts
- https://glossary.cncf.io/container/
Supports
- Containers as isolated processes running from packaged images
- Relationship between container processes and an operating system
- https://glossary.cncf.io/microservices-architecture/
Supports
- Microservices as independently deployable services around application capabilities
- Operational and network complexity introduced by distributed services
- https://glossary.cncf.io/service-mesh/
Supports
- Service-to-service traffic management
- Consistent reliability, observability, and security functions across services
- https://glossary.cncf.io/immutable-infrastructure/
Supports
- Replacement of infrastructure instead of in-place modification
- Version-controlled automation used to recreate infrastructure
- https://opencontainers.org/about/overview/
Supports
- OCI image, distribution, and runtime specifications
- Path from a packaged image to an unpacked runtime bundle and running container
- OCI governance for open container standards
- https://kubernetes.io/docs/concepts/overview/components/
Supports
- Kubernetes control plane and node component responsibilities
- API server, scheduler, controller manager, kubelet, and container runtime roles
- https://kubernetes.io/docs/concepts/overview/working-with-objects/
Supports
- Kubernetes objects as records of intent
- Specification as desired state and status as current observed state
- Control plane management of actual state toward desired state
- https://kubernetes.io/docs/concepts/architecture/controller/
Supports
- Control loops that observe cluster state and move it toward desired state
- Controllers tracking resources through the Kubernetes API
- https://kubernetes.io/docs/concepts/workloads/controllers/
Supports
- Declarative workload APIs and control-plane management of Pods
- Deployments for interchangeable stateless workload replicas
- https://kubernetes.io/docs/concepts/architecture/self-healing/
Supports
- Container restart, replica replacement, rescheduling, volume reattachment, and endpoint removal
- Limits of self-healing for storage failures and application errors
- https://opengitops.dev/
Supports
- Declarative desired state
- Versioned and immutable state storage
- Automatic pull and continuous reconciliation
- https://opentelemetry.io/docs/concepts/observability-primer/
Supports
- Observability through emitted telemetry
- Definitions and roles of metrics, logs, spans, and distributed traces
- Reliability and service level indicators from a user's perspective
- https://github.com/cncf/landscape
Supports
- Landscape as a categorized map of cloud native projects and products
- Multiple possible routes for deploying cloud native applications
