KCNA — What Is Cloud Native
What Is Cloud Native?
The term “cloud native” is central to the KCNA exam. Understanding its definition, principles, and characteristics is essential.
The CNCF Definition
The Cloud Native Computing Foundation (CNCF) provides the official definition:
Cloud-native technologies empower organizations to build and run scalable applications in modern, dynamic environments such as public, private, and hybrid clouds. Containers, service meshes, microservices, immutable infrastructure, and declarative APIs exemplify this approach.
Key takeaway: Cloud native is about how you build and run applications, not just where they run.
Core Properties of Cloud-Native Applications
| Property | Description |
|---|---|
| Scalability | Scale horizontally by adding more instances, not vertically by adding more resources to one instance |
| Resilience | Designed to handle failures gracefully — self-healing, redundancy, circuit breakers |
| Observability | Built-in metrics, logs, and traces for understanding system behavior |
| Manageability | Managed through automation — declarative configuration, GitOps, CI/CD |
| Loosely Coupled | Components communicate through well-defined APIs — changes to one don’t break others |
Cloud Native vs Cloud Hosted
A common misconception is that running in the cloud makes an application “cloud native.”
| Aspect | Cloud Hosted | Cloud Native |
|---|---|---|
| Architecture | Monolithic, lifted-and-shifted | Microservices, designed for the cloud |
| Scaling | Vertical (bigger machines) | Horizontal (more instances) |
| State | Stateful servers | Stateless services with external state |
| Deployment | Manual or semi-automated | Automated CI/CD pipelines |
| Failure Handling | Avoid failures at all costs | Expect and handle failures gracefully |
| Infrastructure | Mutable — patch and update in place | Immutable — replace, don’t repair |
| Configuration | Hardcoded or config files on disk | Externalized (environment variables, ConfigMaps) |
The Five Pillars
Cloud-native applications are built on five pillars:
1. Containers
Package applications and dependencies into portable, isolated units.
2. Microservices
Decompose applications into small, independently deployable services.
3. DevOps
Combine development and operations for faster, more reliable delivery.
4. CI/CD
Automate building, testing, and deploying applications.
5. Declarative APIs
Define desired state and let the platform reconcile — Kubernetes is the prime example.
Immutable Infrastructure
A key cloud-native principle is immutable infrastructure:
- Mutable: SSH into a server → install updates → restart services
- Immutable: Build a new image → deploy it → destroy the old one
Traditional (Mutable) Cloud Native (Immutable)
┌─────────────┐ ┌─────────────┐
│ Server v1 │ │ Image v1 │──── Deploy
│ + patch │ └─────────────┘
│ + update │ ┌─────────────┐
│ + fix │ │ Image v2 │──── Deploy (replace v1)
│ = Server ? │ └─────────────┘
└─────────────┘ ┌─────────────┐
Configuration drift! │ Image v3 │──── Deploy (replace v2)
└─────────────┘
No drift!
Benefits:
- Reproducibility: Every deployment is identical
- Rollback: Just redeploy the previous image
- No configuration drift: Servers are never modified after creation
Declarative vs Imperative
| Approach | Example | Description |
|---|---|---|
| Imperative | “Create 3 pods running Nginx” | Tell the system what to do step by step |
| Declarative | “I want 3 pods running Nginx” | Tell the system what you want — it figures out how |
Kubernetes is declarative:
# Declarative: Define desired state
apiVersion: apps/v1
kind: Deployment
metadata:
name: web
spec:
replicas: 3 # I want 3 pods
selector:
matchLabels:
app: web
template:
metadata:
labels:
app: web
spec:
containers:
- name: nginx
image: nginx:1.25
The Kubernetes controller loop continuously reconciles:
- Observe current state
- Compare to desired state
- Act to close the gap
KCNA Exam Tips
- Know the CNCF definition of cloud native — especially the five key technologies mentioned
- Understand the difference between cloud hosted and cloud native
- Immutable infrastructure and declarative APIs are frequently tested
- Cloud-native applications are designed to be scalable, resilient, observable, and manageable
What’s Next?
Now that you understand what cloud-native means, let’s explore the architecture pattern that makes it possible — microservices.
