67 items with this tag.
The control plane, worker nodes, and core components that make a cluster behave like one programmable system.
How Kubernetes pulls images, delegates execution to runtimes, and lets Pods request different runtime behavior.
The objects that describe running applications: Pods, controllers, rollout strategy, stateful workloads, and batch jobs.
How Pods find each other, receive traffic, and enforce network boundaries inside and outside the cluster.
The storage abstractions that separate container lifecycle from data lifecycle.
How application settings, sensitive values, resource contracts, and cluster access are represented.
How Pods are placed, moved, evicted, and protected from voluntary and involuntary disruption.
The access, identity, workload, and admission controls that keep a cluster from becoming a flat trust zone.
The operational layer: lifecycle, addons, logging, metrics, and maintenance habits.
The APIs and extension patterns that let Kubernetes become a platform for your own operations.
A Kubernetes and platform engineering lab for building reliable personal infrastructure from official documentation and real operations.
A Kubernetes cluster is not a single daemon. It is a small distributed operating system with an API, a database, reconcilers, and agents on each machine.
The control plane is the brain and ledger of the cluster. It accepts desired state, stores it, and runs loops that push reality toward that state.
A node is useful only if kubelet can keep reporting health and can ask the container runtime to run Pods.
Kubernetes works because controllers keep comparing desired state with observed state. That loop is the product.
The core cluster is intentionally incomplete. DNS, ingress, metrics, storage, and policy are choices you compose.
An image is a supply chain artifact. Kubernetes can pull it, but you still own versioning, provenance, size, and rollback behavior.
kubelet does not run containers directly. It talks through the Container Runtime Interface to a runtime such as containerd.
RuntimeClass lets a Pod ask for a different execution environment without changing the application manifest shape.
A Pod is the smallest deployable unit: one network identity, one scheduling decision, and one shared local context for containers.
A Deployment is a rollout controller. ReplicaSets are the machinery it uses to keep the right number of Pods alive.
StatefulSet gives Pods stable identity and ordered behavior. It is for software that notices who it is.
A DaemonSet runs one copy of a Pod across selected nodes. It is how node-level services become cluster-wide.
Jobs are for completion, not serving. CronJobs add a clock to that contract.
Autoscaling is a feedback loop. It needs metrics, resource requests, and a workload that can survive replica changes.
Kubernetes assumes Pods can talk to Pods without NAT. The CNI implementation makes that promise real.
A Service is a stable contract over unstable Pods: name, virtual IP, and selection rules.
EndpointSlices are the scalable backing list of where Service traffic can actually go.
DNS turns Kubernetes objects into names humans and applications can depend on.
Ingress and Gateway API are traffic management layers above Services. They decide how external HTTP traffic reaches internal backends.
NetworkPolicy is a firewall model for Pods, but only if the network plugin enforces it.
A Volume is storage mounted into a Pod. Its lifetime and backend depend on the volume type.
PersistentVolume is supply. PersistentVolumeClaim is demand. Binding connects app needs to storage capacity.
StorageClass is a menu item. Dynamic provisioning turns a PVC into backend storage without manual PV pre-creation.
Ephemeral storage is useful local space with a short memory. It is for runtime needs, not durable truth.
Snapshots are a storage API boundary, not a universal restore guarantee.
ConfigMaps separate non-secret configuration from images so the same artifact can run in different environments.
A Kubernetes Secret is an API object for sensitive material. It is not automatically a complete secrets management program.
Requests are scheduling promises. Limits are enforcement boundaries. Confusing them causes noisy clusters.
kubeconfig is the local routing table for your human access to clusters, users, and namespaces.
The scheduler picks a node for Pods that do not already have one. It filters impossible nodes and scores the rest.
Node assignment is how workloads express where they can or should run.
Taints repel Pods. Tolerations let Pods accept that repulsion. Affinity attracts or separates by labels.
When capacity is scarce, Kubernetes needs rules for who gets scheduled and who gets pushed out.
A disruption budget tells Kubernetes how much voluntary disruption an app can tolerate.
Every meaningful Kubernetes action becomes an API request that must authenticate, authorize, and pass admission.
Service accounts are workload identities. RBAC defines what those identities can do.
Pod security controls the shape of workloads before they run: privilege, host access, users, capabilities, and filesystem behavior.
Admission is the gate between a valid API request and a request the cluster should actually accept.
Secret handling is a full lifecycle: creation, storage, access, rotation, exposure, and deletion.
Cluster planning is deciding what failures you are willing to absorb and what complexity you are willing to operate.
Cluster lifecycle is the repeatable path to install, upgrade, repair, and replace the platform.
Addons are not optional once workloads depend on them. They become part of the platform SLO.
Logs are distributed evidence. Kubernetes gives you streams; you decide retention, routing, and search.
Metrics turn cluster behavior into signals that humans and controllers can act on.
A Custom Resource adds a new API shape. It becomes useful when a controller reconciles it.
An operator packages operational knowledge into a controller. It should make good operations repeatable.
Admission webhooks let external code participate in API decisions at write time.
Plugins let Kubernetes understand capabilities it does not own directly: GPUs, hardware, and custom networking.
Kubernetes APIs evolve. Good platform work knows which versions it depends on and when migrations are coming.
Study notes for the CKA/CKAD certification on the main deployment strategies in K8s.
Explorando Tailscale para dar redundancia a un homelab y exponer servicios de forma segura: una alternativa limpia para arquitecturas multi-cloud.
Exploring Tailscale as a solution for home lab redundancy and secure service exposure - a clean alternative for multi-cloud architectures.
Architecture decisions and lessons learned scaling AI agentic systems on GCP with Kubernetes, Helm, and Secret Manager.
Architecture decisions and lessons learned scaling AI agentic systems on GCP with Kubernetes, Helm, and Secret Manager.
Architecture decisions and lessons learned scaling AI agentic systems on GCP with Kubernetes, Helm, and Secret Manager.
Environment Variables Python Virtual Env .env .env Steps for Venv python -m venv env_name Create kernel medium.com/@WamiqRaza/how-to-create-virtual-environment-jupyter-kernel-python-6836b50f4bf4 .