Fundamentals

The Fundamentals section is your starting point for understanding Kubernetes. Here, you’ll learn the core concepts, architecture, and principles that form the foundation of everything Kubernetes does. Think of this section as learning the language and grammar before writing sentences—once you understand these fundamentals, everything else in Kubernetes will make more sense.

Kubernetes can seem complex at first, but it’s built on a set of well-defined concepts that work together. This section breaks down those concepts into digestible pieces, explaining not just what Kubernetes does, but why it works the way it does. You’ll learn about the architecture that makes Kubernetes reliable, the API that makes it programmable, and the objects that represent everything in your cluster.

What You’ll Learn

The Fundamentals section covers the essential building blocks of Kubernetes:

Basics - Core concepts like what Kubernetes is, how clusters and namespaces work, and the fundamental unit of deployment: pods
Architecture - How Kubernetes is built, from the control plane components to worker nodes and the etcd database
APIs & Access - How to interact with Kubernetes through its RESTful API, understanding API groups, versions, and client tools
API Objects - The resources that represent everything in Kubernetes, from core objects to workload controllers
Packaging - Tools and patterns for managing Kubernetes configurations
Scheduling - How Kubernetes decides where to run your workloads
CRDs - Extending Kubernetes with custom resources
Security - The security model and basic security concepts
High Availability - Making Kubernetes resilient to failures
Installation - Approaches and concepts for getting Kubernetes running

graph TB A[Fundamentals] --> B[Basics] A --> C[Architecture] A --> D[APIs & Access] A --> E[API Objects] A --> F[Packaging] A --> G[Scheduling] A --> H[CRDs] A --> I[Security] A --> J[High Availability] A --> K[Installation] B --> B1[What is K8s] B --> B2[Cluster vs Namespace] B --> B3[Pods 101] C --> C1[Control Plane] C --> C2[Node & Kubelet] C --> C3[etcd] D --> D1[API Groups] D --> D2[Discovery] D --> D3[Clients] E --> E1[Core Objects] E --> E2[Workload Objects] F --> F1[Helm vs Kustomize] style A fill:#e1f5ff style B fill:#fff4e1 style C fill:#fff4e1 style D fill:#fff4e1 style E fill:#fff4e1 style F fill:#fff4e1 style G fill:#fff4e1 style H fill:#fff4e1 style I fill:#fff4e1 style J fill:#fff4e1 style K fill:#fff4e1

Learning Path

While you can read these topics in any order, we recommend this learning path for beginners:

Start with Basics - Understand what Kubernetes is and its core concepts
Learn Architecture - See how the components fit together
Explore APIs & Access - Learn how to interact with Kubernetes
Study API Objects - Understand the resources you’ll work with daily
Dive into Specialized Topics - Scheduling, CRDs, security, and more as needed

Each topic builds on previous concepts, but they’re also designed to stand alone if you need to reference a specific concept.

Core Concepts Overview

The Kubernetes Model

Kubernetes follows a declarative model: you describe what you want, and Kubernetes works to make that state reality. This is fundamentally different from imperative systems where you issue commands to do specific actions. In Kubernetes, you create objects (like Deployments or Services) that describe your desired state, and controllers continuously work to maintain that state.

Everything is an API Object

In Kubernetes, everything is represented as an API object—pods, services, deployments, nodes, namespaces, and more. These objects have a consistent structure with metadata (name, labels, annotations), a specification (what you want), and a status (current state). This uniform model makes Kubernetes predictable and programmable.

The Control Loop

Kubernetes uses a control loop pattern throughout. Controllers watch the current state of objects and compare it to the desired state. When they detect differences, they take action to reconcile them. This self-healing capability is one of Kubernetes’ most powerful features—if a pod crashes, Kubernetes creates a new one. If a node fails, Kubernetes reschedules pods elsewhere.

Extensibility

Kubernetes is designed to be extended. You can add custom resources (CRDs), create operators that manage complex applications, extend the scheduler, add admission webhooks, and more. This extensibility means Kubernetes can adapt to your specific needs without requiring changes to the core system.

Topics

Core Concepts

Basics of Kubernetes - Introduction to Kubernetes basics, clusters, namespaces, and pods
Kubernetes Architecture - Understanding how Kubernetes is built and how components interact
API Objects - The resources that represent everything in Kubernetes

API and Access

APIs & Access - How to interact with Kubernetes through its API
Scheduling Overview - How Kubernetes decides where to run workloads

Packaging and Configuration

Helm & Kustomize - Tools for managing Kubernetes configurations
Installation & Configuration Overview - Approaches to installing and configuring Kubernetes

Advanced Concepts

CRDs - Extending Kubernetes with Custom Resource Definitions
Security Overview - Kubernetes security model and concepts
High Availability Overview - Making Kubernetes resilient

How Fundamentals Relate to Other Sections

Understanding fundamentals prepares you for the other sections of this documentation:

Workloads & Scheduling - Builds on API objects and scheduling concepts
Services & Networking - Uses your understanding of pods, services, and the API
Storage - Extends your knowledge of volumes and persistent storage objects
Security - Deepens the security overview with detailed implementations
Observability - Helps you understand what to monitor based on architecture knowledge
GitOps & Automation - Uses API knowledge to automate operations
Cluster Operations - Applies architecture knowledge to cluster management

Getting Started

If you’re new to Kubernetes, start with What is Kubernetes? to understand the big picture, then work through the Basics section. If you have some Kubernetes experience but want to deepen your understanding, jump to the Architecture section to see how everything fits together.

Each page in this section includes examples, diagrams, and clear explanations. Don’t worry if some concepts seem abstract at first—they’ll become concrete as you start working with Kubernetes in practice.