Cloud Native Architecture (16%)

The 12-Factor App

The 12-Factor App is a methodology for building software-as-a-service applications. It provides best practices for portability, scalability, and maintainability. Every Kubernetes-native application should follow these principles.

1. I. Codebase — One codebase tracked in version control, many deploys.
2. II. Dependencies — Explicitly declare and isolate dependencies.
3. III. Config — Store config in the environment, not in code.
4. IV. Backing services — Treat backing services as attached resources.
5. V. Build, release, run — Strictly separate build and run stages.
6. VI. Processes — Execute the app as stateless processes.
7. VII. Port binding — Export services via port binding.
8. VIII. Concurrency — Scale out via the process model.
9. IX. Disposability — Maximize robustness with fast startup and graceful shutdown.
10. X. Dev/prod parity — Keep development, staging, and production as similar as possible.
11. XI. Logs — Treat logs as event streams.
12. XII. Admin processes — Run admin tasks as one-off processes.

Autoscaling

Kubernetes provides three autoscaling mechanisms that work together to handle variable load.

kubectl autoscale deployment my-app \
  --min=2 --max=10 --cpu-percent=70

Serverless on Kubernetes

Serverless on Kubernetes means running functions-as-a-service or event-driven workloads without managing the underlying infrastructure. Knative is the standard serverless platform for Kubernetes.

• Knative Serving — Scale to zero, automatic scaling, traffic splitting.
• Knative Eventing — Event-driven architectures with brokers, triggers, and sources.
• OpenFaaS — Functions as a service on Kubernetes.
• Virtual Kubelet — Connect serverless providers to Kubernetes.

CNCF Landscape

The CNCF (Cloud Native Computing Foundation) hosts the cloud native ecosystem. Projects are categorized by maturity: Sandbox, Incubating, and Graduated. Key graduated projects include Kubernetes, Prometheus, Envoy, CoreDNS, and containerd.

Community Roles

The Kubernetes community has defined roles for contributors at every level. Understanding these roles shows you understand how open-source governance works.

• Kubernetes Member (KM) — Entry-level contributor recognition.
• Reviewer — Reviews pull requests for code quality.
• Approver — Has merge authority for specific areas.
• Kubernetes Maintainer — Long-term contributor with broad merge authority.
• SIG (Special Interest Group) — Topic-focused working groups (e.g., SIG-Network, SIG-Storage).

Architecture Design Principles

Cloud native architecture favors loose coupling, microservices, containerization, and ephemeral infrastructure. The goal is resilience through redundancy, not through durable servers.

• Design for failure — Assume components will fail and build recovery into the system.
• Embrace ephemeral infrastructure — Nodes, Pods, and even clusters should be replaceable.
• Automate everything — From deployment to scaling to recovery, automation is non-negotiable.
• Observe your systems — Metrics, logs, and traces provide the visibility needed to operate.

Key Takeaways