Kubernetes
293 bites tagged Kubernetes — interview questions with model answers, and 60-second explainers.
Kubernetes API Aggregation Layer: Extending the API Server
The API Aggregation Layer bolts custom API servers onto the main Kubernetes API, with `kube-apiserver` acting as a proxy. This powers features like the metrics server (`kubectl top`) and enables complex extensions.
controller-runtime: The Engine for Kubernetes Operators
Think of controller-runtime as the standard library for writing Kubernetes controllers. It handles the boilerplate of watching resources and reconciling state, forming the foundation for tools like Kubebuilder and Operator SDK.
Kubernetes Finalizers: The 'Do Not Delete Yet' Lock
A finalizer is a pre-deletion lock. It tells Kubernetes to block an object's deletion until a controller cleans up external resources, like a cloud database or storage bucket.
Operator SDK: Build Kubernetes Operators Faster
The Operator SDK is a developer toolkit that scaffolds the boilerplate for building, testing, and packaging Kubernetes Operators. Use it to automate complex application lifecycle management, like deploying a database cluster that can self-heal and perform…
kubectl Treats Custom Resources Like Native Ones
`kubectl` interacts with Custom Resources (CRs) using the same commands you know for built-in types like Pods. Once a CRD is installed, you can `kubectl get`, `describe`, and `delete` its objects.
The Operator Pattern: A Robot SRE for Your App
The Operator pattern adds a custom, automated "robot SRE" to your Kubernetes cluster. It encodes human operational knowledge for a specific application, like a database, into software that handles complex tasks like upgrades, backups, and failovers…
Custom Resource Definitions (CRDs): Teach Kubernetes New Tricks
CRDs let you define your own resource types, teaching Kubernetes new nouns like `Database` or `Backup`. This is how operators manage complex apps declaratively. The footgun is that a CRD only defines the API; you still need a controller to act on the objects.
Helm Post-Rendering: Customize Charts Without Forks
Helm post-rendering lets you modify a chart's Kubernetes manifests just before deployment. It's ideal for applying `kustomize` patches or injecting sidecars without forking a public chart.
Flux Image Update Automation: Closing the GitOps Loop
Flux's image update automation acts like a bot that watches your container registry. It finds new image tags that match your policies (like semver) and automatically commits the change back to your Git repository, triggering a deployment.
Argo CD Sync Phases and Waves: Ordering Your Deployments
Argo CD Sync Phases and Waves are a recipe for ordering deployments. Use them for complex apps where a database migration must run pre-sync. The footgun: a single failed resource in a wave halts the entire sync process, making it brittle if overused.
Helm Hooks: Running Operations During a Release
Helm Hooks are Kubernetes resources that run at specific moments in a release lifecycle. Use them to run a database migration before an app upgrade or to back up data before a deletion. The footgun: a failing hook Job will block and fail the entire.
Helm Subcharts: Composing Applications from Dependencies
Helm subcharts are nested components a parent chart can configure, like a docker-compose for Kubernetes manifests. Use them to bundle dependencies like a database with your app. The footgun: subcharts are sandboxed and cannot access parent values directly.
Configuration Drift: When Live State Betrays Git
Configuration drift is when your live system's state no longer matches its Git source of truth. GitOps tools like Argo CD detect this by constantly comparing live resources to Git, flagging any discrepancies.
Helm Templates: Turning Static YAML into Dynamic Manifests
Think of Helm templating as a mail merge for Kubernetes. It combines static YAML templates with dynamic values to generate manifests for different environments. Use it to manage configurations for dev, staging, and prod.
Helm Repository: Your Private App Store for Kubernetes
A Helm repository is a private app store for your Kubernetes applications. It's just an HTTP server with a catalog file (`index.yaml`) pointing to your packaged charts. Use it to share reusable app templates across teams without using public registries.
Helm: The Package Manager for Kubernetes
Helm is like apt or Homebrew for Kubernetes. It bundles all your app's YAML files into a single manageable package called a Chart, solving "YAML sprawl." Use it to install complex apps with one command or to package your own for repeatable deployments.
GitOps Principles: Your Repo as the Source of Truth
GitOps treats infrastructure state like code, with your Git repo as the single source of truth. Automated agents pull declarative configs from the repo to reconcile the live system, making it ideal for Kubernetes.
Service Mesh Observability: Seeing Inside the Black Box
A service mesh provides observability by intercepting all service-to-service traffic. It automatically generates logs, metrics, and traces, helping you debug distributed systems without changing application code.
Prometheus Alertmanager: Taming Your Alert Storms
Alertmanager is the traffic controller for your Prometheus alerts, turning a potential flood into actionable notifications. It groups, deduplicates, and routes alerts to services like PagerDuty. The footgun: don't load balance traffic to an HA cluster.
cAdvisor: A Task Manager for Containers
cAdvisor is like a task manager for your containers, giving you a live view of their resource usage. It's used to track performance, historical usage, and network stats for every container on a host.
Prometheus Exporters: Translating Metrics for Monitoring
A Prometheus Exporter is a translator, converting metrics from third-party systems like databases or hardware into the format Prometheus can scrape. Use one when you can't modify an app's code directly.
Prometheus Architecture: A Pull-Based Monitoring System
Prometheus is a monitoring system that actively pulls metrics from your services, rather than waiting for them to push data. It's the standard for tracking performance in dynamic environments like Kubernetes.
Kubernetes Cluster-Level Logging
Cluster-level logging treats logs as a stream, not as files on ephemeral pods. It centralizes logs from all nodes before they disappear when a pod dies, which is essential for debugging any production application.
Kubernetes Metrics Server: The Engine for Autoscaling
Metrics Server is the dedicated speedometer for your cluster's pods, feeding CPU and memory usage to Kubernetes's autoscalers. It powers the Horizontal and Vertical Pod Autoscalers and the `kubectl top` command. The footgun: it's *only* for autoscaling.
Get Kubernetes bites daily.
Five a day, five minutes, offline. With quizzes so it sticks.
Open testing — you’ll join as an early tester.