DevOps Kubernetes Syllabus

Kubernetes syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Kubernetes in DevOps, not a summary of it.

1. 1

   Introduction to Kubernetes

   2 topics

   • What is Kubernetes?
     • History and Evolution
     • Core Concepts
     • Use Cases
   • Kubernetes Architecture
     • Master and Node Components
     • API Server
     • etcd
     • Controller Manager
     • Scheduler
     • Kubelet
     • Kube Proxy
2. 2

   Setting Up Kubernetes

   2 topics

   • Installation Methods
     • Minikube
     • Kubeadm
     • K3s
     • Managed Kubernetes Services (GKE, EKS, AKS)
   • Configuration and Setup
     • Configuring kubectl
     • Cluster Configuration Files
     • Networking Setup
3. 3

   Core Concepts and Objects

   6 topics

   • Pods
     • Pod Lifecycle
     • Multi-Container Pods
   • ReplicaSets and Deployments
     • Scaling Applications
     • Rolling Updates and Rollbacks
   • Services
     • Service Types (ClusterIP, NodePort, LoadBalancer)
     • DNS and Service Discovery
   • ConfigMaps and Secrets
     • Managing Configuration Data
     • Storing Sensitive Information
   • Volumes and Persistent Storage
     • Volume Types
     • Persistent Volume Claims
   • Namespaces
     • Namespace Isolation
     • Resource Quotas and Limits
4. 4

   Advanced Kubernetes Concepts

   5 topics

   • Helm
     • Helm Charts
     • Chart Repositories
     • Helm Releases
   • Operators
     • Custom Resource Definitions (CRDs)
     • Operator Patterns
   • StatefulSets
     • Stateful Applications
     • Persistent Storage for StatefulSets
   • DaemonSets
     • Node-Level Operations
     • Use Cases for DaemonSets
   • Jobs and CronJobs
     • Running Batch Jobs
     • Scheduled Jobs
5. 5

   Security in Kubernetes

   4 topics

   • Authentication and Authorization
     • RBAC (Role-Based Access Control)
     • Service Accounts
   • Network Policies
     • Isolating Pods
     • Network Policy Implementations
   • Pod Security Policies
     • Security Contexts
     • Pod Security Standards
   • Image Security
     • Image Scanning
     • Using Trusted Registries
6. 6

   Monitoring and Logging

   2 topics

   • Monitoring
     • Prometheus
     • Grafana
     • Metrics Server
   • Logging
     • Elasticsearch, Fluentd, Kibana (EFK) Stack
     • Centralized Logging Solutions
7. 7

   Scaling and High Availability

   3 topics

   • Horizontal Pod Autoscaler
     • Configuring HPA
     • Metrics for Autoscaling
   • Cluster Autoscaler
     • Node Scaling
     • Autoscaler Configurations
   • High Availability
     • HA for Master Nodes
     • HA for etcd
8. 8

   Troubleshooting and Best Practices

   2 topics

   • Troubleshooting
     • Common Issues
     • Debugging Tools
   • Best Practices
     • Resource Management
     • Security Best Practices
     • CI/CD Integration

Kubernetes flashcards for DevOps

23 of 72 cards from the Kubernetes deck — real questions with worked answers.

1. What is Kubernetes?

   Kubernetes (often abbreviated K8s) is an open-source container orchestration platform that automates the deployment, scaling, load balancing, self-healing, and management of containerized applications across a cluster of machines. It was originally developed by Google and is now maintained by the Cloud Native Computing Foundation (CNCF).

2. Why is Kubernetes abbreviated as "K8s"?

   "K8s" is a numeronym: the "8" replaces the eight letters between the "K" and the "s" in "Kubernetes" (u-b-e-r-n-e-t-e).

3. What problem does Kubernetes solve compared to running raw containers?

   Raw containers (e.g., plain Docker) lack built-in scheduling, self-healing, scaling, service discovery, and rollout management. Kubernetes adds a declarative control plane that continuously reconciles the actual cluster state toward a desired state, automatically restarting failed containers, rescheduling them on healthy nodes, and scaling them up or down.

4. What is the difference between the desired state and the current state in Kubernetes?

   The desired state is what you declare in manifests (e.g., "run 3 replicas"). The current (actual) state is what is really running. Kubernetes controllers run a continuous reconciliation loop that takes action to drive the current state toward the desired state.

5. What are the two main parts of the Kubernetes cluster architecture?

   The control plane (master components that make global decisions and manage the cluster) and the worker nodes (machines that run the actual application workloads in Pods).

6. Name the core components of the Kubernetes control plane.

   kube-apiserver (front-end API), etcd (key-value store for cluster state), kube-scheduler (assigns Pods to nodes), kube-controller-manager (runs controllers), and cloud-controller-manager (integrates with the cloud provider).

7. What is etcd in Kubernetes and why is it critical?

   etcd is a consistent, distributed, highly available key-value store that holds all cluster data and configuration (the single source of truth for cluster state). Losing etcd without a backup means losing the entire cluster state, so it must be backed up regularly.

8. What is the role of the kube-apiserver?

   The kube-apiserver exposes the Kubernetes REST API and is the central front end of the control plane. All components and users communicate through it; it validates and processes requests and persists state to etcd. It is the only component that talks directly to etcd.

9. What does the kube-scheduler do?

   The kube-scheduler watches for newly created Pods with no assigned node and selects the best node for each based on resource requirements, constraints, affinity/anti-affinity rules, taints/tolerations, and available capacity.

10. What are the key components that run on every worker node?

    kubelet (agent that ensures containers in Pods are running), kube-proxy (maintains network rules for Services), and a container runtime (e.g., containerd or CRI-O) that actually runs the containers.

11. What is the kubelet?

    The kubelet is the primary node agent that runs on each worker node. It registers the node with the API server, watches for Pod specs assigned to its node, and ensures the described containers are running and healthy via the container runtime.

12. What is the Container Runtime Interface (CRI)?

    The CRI is the standardized gRPC API that the kubelet uses to talk to container runtimes. It lets Kubernetes work with any compliant runtime (containerd, CRI-O, etc.) instead of being tied to one. Note: Docker's dockershim was removed in Kubernetes v1.24.

13. List common methods for installing/bootstrapping a Kubernetes cluster.

    kubeadm (official cluster bootstrapping tool), Minikube (single-node local cluster), kind (Kubernetes in Docker), k3s/MicroK8s (lightweight distributions), managed services (EKS, GKE, AKS), and kops or kubespray for production self-managed clusters.

14. What is kubeadm used for?

    kubeadm is the official tool that bootstraps a minimum viable, best-practice Kubernetes cluster. The key commands are `kubeadm init` (to set up the control-plane node) and `kubeadm join` (to add worker nodes to the cluster).

15. What is the difference between Minikube and kind?

    Both create local clusters for development. Minikube typically runs a single-node (or limited multi-node) cluster inside a VM or container and includes addons. kind (Kubernetes IN Docker) runs cluster nodes as Docker containers, making it lightweight and well-suited for CI and multi-node testing.

16. What is kubectl and what is a kubeconfig file?

    kubectl is the command-line tool used to communicate with a cluster's API server to deploy and manage resources. The kubeconfig file (default `~/.kube/config`) stores cluster connection details, credentials, and contexts that kubectl uses to know which cluster/user/namespace to target.

17. What is the difference between imperative and declarative configuration in Kubernetes?

    Imperative commands tell Kubernetes exactly what to do step by step (e.g., `kubectl create`, `kubectl run`). Declarative configuration describes the desired end state in YAML/JSON manifests applied with `kubectl apply -f`, letting Kubernetes figure out the changes needed. Declarative is preferred for reproducibility and version control.

18. What four top-level fields must virtually every Kubernetes manifest contain?

    apiVersion (the API group/version), kind (the resource type, e.g., Pod or Deployment), metadata (name, namespace, labels, annotations), and spec (the desired state specification of the object).

19. What is a Pod in Kubernetes?

    A Pod is the smallest deployable unit in Kubernetes. It is a group of one or more containers that share the same network namespace (a single IP address and port space), storage volumes, and lifecycle, and are always scheduled together on the same node.

20. Why are containers within the same Pod tightly coupled?

    Containers in one Pod share the same network namespace (so they reach each other via `localhost`), can share mounted volumes, and are co-scheduled and co-located on the same node. This makes Pods ideal for helper patterns like a main container plus a tightly coupled sidecar.

21. What is the sidecar container pattern?

    The sidecar pattern places a secondary helper container in the same Pod as the main application container to extend or enhance it, sharing the Pod's network and volumes. Common uses include log shippers, proxies (service mesh), and data synchronizers.

22. What are init containers?

    Init containers are specialized containers in a Pod that run to completion, one at a time and in order, before the main application containers start. They are used for setup tasks such as waiting for a dependency, cloning a repo, or running database migrations.

23. Why are Pods considered ephemeral, and what is the implication?

    Pods are mortal: they are created and destroyed and are never resurrected with the same identity (a new Pod gets a new IP). Because their IPs are unstable, you should not connect directly to Pod IPs; instead use a Service for a stable network endpoint.

See more Kubernetes flashcards →

Planning Kubernetes for DevOps

Kubernetes (DevOps) FAQ