[2026-06-08] ingest | CKA Day 15: Kubernetes Node Affinity Explained | Tech Tutorials with Piyush
Ingested Day 15 of the 40-day CKA course — the advanced positive scheduling primitive: nodeAffinity with requiredDuringSchedulingIgnoredDuringExecution (hard) and preferredDuringSchedulingIgnoredDuringExecution (soft).
Documented Node Affinity as the expressive successor to nodeSelector, supporting rich operators (In, NotIn, Exists, DoesNotExist, Gt, Lt), multiple values, and soft/hard constraints. Emphasised the IgnoredDuringExecution suffix: changes to node labels do not evict already-scheduled Pods.
Synthesised the critical distinction between Node Affinity (attracts Pods to nodes) and Taints/Tolerations (repels Pods from nodes). Taints alone cannot guarantee placement on a specific node type; they only grant permission to land on tainted nodes. Affinity actively pulls the Pod toward the desired pool.
Documented the production pattern: taints + tolerations + requiredDuringScheduling node affinity creates a “double-gated” dedicated node pool (e.g., GPU, high-memory). Taints repel general workloads; affinity ensures the workload lands on the right nodes.
Created Kubernetes Node Affinity concept page with full YAML anatomy, operator reference, troubleshooting matrix, CKA speed patterns, and the taints+affinity integration pattern.
Updated Kubernetes Manual Scheduling — expanded the Node Affinity section with the IgnoredDuringExecution distinction and deep-dive cross-link.
Updated Kubernetes Taints and Tolerations — enriched the “Production Pattern” section with the “why both are needed” explanation and cross-link to the new Node Affinity deep-dive.
[2026-06-08] ingest | CKA Day 14: Taints and Tolerations in Kubernetes | Tech Tutorials with Piyush
Ingested Day 14 of the 40-day CKA course — the negative scheduling primitive: taints on nodes, tolerations on Pods, and the three effects (NoSchedule, PreferNoSchedule, NoExecute).
Documented taints as node-level “Do Not Disturb” signs and tolerations as Pod-level exemptions. Explained the imperative kubectl taint syntax and the YAML tolerations block with Equal and Exists operators.
Catalogued built-in taints: node-role.kubernetes.io/control-plane, node.kubernetes.io/not-ready, node.kubernetes.io/unreachable, node.kubernetes.io/memory-pressure, and node.kubernetes.io/disk-pressure — all applied automatically by the node controller.
Documented DaemonSet toleration patterns: why kube-proxy and CNI agents must tolerate the control-plane taint to run on master nodes, and the common exam trap of missing tolerations on custom DaemonSets.
Synthesized the production pattern: combining nodeAffinity (attract) with taints/tolerations (repel) to create dedicated node pools for GPU, high-memory, or critical workloads.
Created Kubernetes Taints and Tolerations concept page with full YAML anatomy, built-in taint catalog, troubleshooting matrix, and CKA speed patterns.
Updated Kubernetes Manual Scheduling — expanded the taints/tolerations section with references to the new deep-dive page.
Updated CKA Study Roadmap — corrected Day 14 topic from “Resource Quotas & Limits” to “Taints, Tolerations & Node Affinity Deep Dive”.
[2026-06-08] ingest | CKA Day 13: Static Pods, Manual Scheduling, Labels, and Selectors in Kubernetes | Tech Tutorials with Piyush
Ingested Day 13 of the 40-day CKA course — the low-level scheduling primitives: Static Pods, manual scheduling, labels, and selectors.
Documented Static Pods: the kubelet-managed Pods that bootstrap the control plane. Explained the /etc/kubernetes/manifests directory, the visibility-only reporting to the API server, and the critical exam trap that kubectl delete will not remove them.
Documented Manual Scheduling: three techniques to bypass or constrain the scheduler — nodeName (direct, no validation), nodeSelector (label-based, scheduler-validated), and nodeAffinity (advanced soft/hard constraints). Covered taints and tolerations as the inverse scheduling mechanism.
Documented Labels and Selectors: the metadata and query system that binds every Kubernetes object. Contrasted equality-based vs set-based selectors, highlighted the Service selector vs Deployment matchLabels syntax trap, and distinguished annotations from labels.
Created Kubernetes Static Pods concept page with manifest anatomy, Static Pod vs DaemonSet vs Deployment comparison table, and control plane troubleshooting commands.
Created Kubernetes Labels and Selectors concept page with selector types, kubectl label management commands, NetworkPolicy examples, and the critical YAML format distinction.
Created Kubernetes Manual Scheduling concept page with nodeName, nodeSelector, nodeAffinity, and taints/tolerations comparison tables and CKA speed patterns.
Updated Kubernetes Architecture — added dedicated Static Pods and Control Plane Bootstrapping section with comparison table.
Updated CKA Study Roadmap — corrected Day 13 topic from “Rolling Updates & StatefulSets” to “Static Pods, Manual Scheduling, Labels & Selectors”.
[2026-06-08] ingest | CKA Day 12: DaemonSet, Job & CronJob Explained | Tech Tutorials with Piyush
Ingested Day 12 of the 40-day CKA course — specialized workload controllers: DaemonSet, Job, and CronJob.
Documented DaemonSet: the node-level controller that ensures one Pod per node for monitoring agents, CNI plugins, and log shippers. Contrasted with Deployment (horizontal replicas vs. node axis coverage).
Documented Job: the finite-batch controller that runs Pods to completion with configurable completions, parallelism, backoffLimit, and activeDeadlineSeconds. Emphasized the invalidity of restartPolicy: Always inside Job templates.
Documented CronJob: the time-based scheduler that wraps Jobs with cron expressions, supporting concurrencyPolicy, suspend, and history limits for production automation.
Created Kubernetes DaemonSet concept page with YAML anatomy, node selector/taint patterns, and CKA speed commands.
Created Kubernetes Jobs concept page with parallel execution patterns, lifecycle phases, and exam restrictions.
Created Kubernetes CronJobs concept page with cron syntax, concurrency policies, and history management.
Updated Kubernetes Concepts Index — added DaemonSet, Jobs, and CronJobs to the Workloads & Scheduling section.
Updated CKA Study Roadmap — corrected Day 12 topic to “DaemonSets, Jobs & CronJobs” and shifted downstream days accordingly.
[2026-06-03] ingest | CKA Day 11: Multi Container Pod Kubernetes — Sidecar vs Init Container | Tech Tutorials with Piyush
Ingested Day 11 of the 40-day CKA course — multi-container Pods, init containers, sidecars, environment variables, and command/argument overrides.
Documented environment variables in Kubernetes: literal values, configMapKeyRef, secretKeyRef, and Downward API (fieldRef) injection patterns.
Synthesized multi-container Pod patterns: sidecar (logging/monitoring), init (setup/validation), adapter (output transformation), and ambassador (proxy) — with shared network namespace, storage volumes, and scheduling implications.
Created Multi-Container Pods concept page with YAML anatomy, container role comparison, troubleshooting table, and CKA speed patterns.
Created Init Containers concept page covering sequential execution, common use cases (dependency waiting, migrations, permissions), resource scheduling impact, and debugging commands.
Created Sidecar Pattern concept page with five canonical use cases (log shipping, metrics exporter, service mesh proxy, config reloader, TLS termination), anti-patterns, and the sidecar-vs-init container decision matrix.
Created Kubernetes Environment Variables concept page with literal, ConfigMap, Secret, Downward API, and envFrom patterns, plus encode/decode helpers and troubleshooting.
Created Pod Commands and Arguments concept page mapping Kubernetes command/args to Docker ENTRYPOINT/CMD, override scenarios, shell patterns, and exam traps.
Updated Pod Fundamentals — enriched Related Pages with links to the five new multi-container concept pages.
Updated CKA Certification — added Day 11 source to the Sources list.
Updated CKA Study Roadmap — clarified Day 6 topic to include sidecars alongside init containers.
Updated Kubernetes Concepts Index — added entries for Multi-Container Pods, Init Containers, Sidecar Pattern, Environment Variables, and Pod Commands/Arguments.
[2026-05-30] ingest | CKA Day 10: Kubernetes Namespace Explained | Tech Tutorials with Piyush
Ingested Day 10 of the 40-day CKA course — the logical isolation primitive that enables multi-tenancy, resource governance, and clean service discovery.
Documented the four default Namespaces: default (user workloads), kube-system (control plane components), kube-public (cluster metadata), and kube-node-lease (heartbeat leases).
Synthesized Namespace-scoped vs Cluster-scoped resources: critical for RBAC design and CKA exam questions.
Catalogued imperative and declarative namespace creation: kubectl create ns, kubectl apply -f ns.yaml, and persistent context switching with kubectl config set-context --current --namespace.
Explained cross-namespace service discovery via FQDN (<service>.<namespace>.svc.cluster.local) and how microservices communicate across team boundaries.
Introduced ResourceQuota and LimitRange as the governance layer enforced at Namespace boundaries.
Documented NetworkPolicy namespaceSelector for true network isolation between Namespaces.
Created Kubernetes Namespaces concept page with YAML patterns, exam commands, troubleshooting, and best-practice patterns.
Updated CKA Study Roadmap — corrected Day 10 topic from “Phase 1 Review” to actual video content (Namespaces).
[2026-05-28] ingest | CKA Day 9: Kubernetes Services Explained | Tech Tutorials with Piyush
Ingested Day 9 of the 40-day CKA course — the networking abstraction that turns ephemeral Pods into stable, discoverable endpoints.
Documented the four Service types: ClusterIP (internal default), NodePort (external static port 30,000–32,767), LoadBalancer (cloud-provisioned LB), and ExternalName (DNS alias).
Synthesized the three port concepts: targetPort (container listens here), port (Service exposes this internally), and nodePort (external access on each node).
Explained Endpoints: the dynamic backend list that automatically updates as Pods churn, enabling Service stability despite ephemeral Pod IPs.
Catalogued imperative service creation: kubectl expose deployment ... --type=NodePort --node-port=30001 for exam speed.
Documented the Kind cluster NodePort gotcha: extraPortMappings required because Kind runs K8s inside Docker containers.
Created Kubernetes Services concept page with YAML anatomy, routing mechanics, troubleshooting table, and command reference.
Created Kubernetes Service Types concept page with detailed comparison, access patterns, exam traps, and decision flowchart.
Updated CKA Study Roadmap — corrected Day 9 topic from “Static Pods & Pod Lifecycle” to actual video content (Services).
Updated Kubernetes Architecture — added kube-proxy routing note and Endpoints update flow in the self-healing diagram.
Updated Kind Cluster Setup — expanded port mapping section with NodePort-specific guidance.
Updated Pod Fundamentals — added “Pod IP Ephemerality” section explaining why Services are essential.
Documented ReplicaSet (apps/v1): modern replacement with selector.matchLabels for flexible Pod adoption; the building block of Deployments.
Documented Deployment (apps/v1): the production standard providing self-healing, scaling, rolling updates, and rollback capabilities.
Synthesized the object hierarchy: Deployment → ReplicaSet → Pod, and how Kubernetes creates new ReplicaSets during rolling updates while scaling old ones down.
Catalogued essential kubectl commands: scale, set image, rollout history, rollout undo, and --dry-run=client -o yaml for manifest generation.
Emphasized CKA exam speed patterns: imperative commands over YAML editing, vi shortcuts (Shift+A), and using --help for copy-pasteable examples.
[2026-05-21] refactor | Standardize Index page domain formatting and add Recently Updated section
Audited content/index.md against all 78 wiki files and identified 4 inconsistent formatting patterns across 9 domain sections.
Standardized all domains to unified | Page | Description | table format with single-link rows.
Extracted AI & LLMs from main Index into dedicated [[wiki/concepts/AI/Index|AI & LLMs Index]] with rich sub-tables (Claude Code, Workflows, SDLC, Infrastructure, Observability, Career) — prevents 23+ rows from dominating the main catalog.
Added 7 orphaned wiki pages to main Index: Docker-Fundamentals, Dockerize-Project, Why-Kubernetes, Kubernetes-Architecture, Kind-Cluster-Setup, Pod-Fundamentals, cap-theorem-system-design.
Reordered domains by activity: Kubernetes & CKA → AI & LLMs → Docker → Security → System Design → Observability → Tooling → Blockchain → Programming.
Added “Recently Updated” section to main Index pulling last 6 ingestions from log — gives returning visitors an at-a-glance view of what’s new.
Added Tech-Tutorials-with-Piyush to Entities table with standardized | Entity | Role | format.
Standardized link escaping to \| across all entries for consistent Markdown parsing.
[2026-05-21] ingest | CKA Day 7: Pod Explained — Imperative vs Declarative | Tech Tutorials with Piyush
Ingested Day 7 of the 40-day CKA course — foundational Pod concepts and the two paradigms of cluster interaction.
Documented Pod fundamentals: the smallest deployable unit, shared network/storage namespaces, multi-container patterns, and lifecycle phases (Pending, Running, Succeeded, Failed, Unknown).
Synthesized Imperative vs Declarative approaches: kubectl commands for quick tasks vs YAML manifests for Infrastructure-as-Code workflows.
Created a YAML tutorial for beginners covering indentation rules, key-value pairs, lists, nested objects, and Kubernetes-specific tips (kubectl explain, --dry-run=client).
Provided practical examples: single-container Pod, multi-container Pod with sidecar, and essential kubectl commands (run, get, describe, delete, exec, logs).
Synthesized communication flows: how a user request travels through kubectl → API Server → etcd → scheduler → kubelet → runtime, and how self-healing loops work when pods fail.
Created the Kubernetes Architecture concept page with detailed component tables, communication diagrams, HA strategies, and exam commands.
[2026-05-21] ingest | CKA Day 4: Why Kubernetes Is Used | Tech Tutorials with Piyush
Ingested Day 4 of the 40-day CKA course — the conceptual foundation of why Kubernetes exists and what problems it solves.
Documented the 6 problems of Docker at scale: no auto-healing, no auto-scaling, no load balancing, manual deployments, no service discovery, host-bound containers.
Synthesized the Kubernetes solutions: self-healing pods, HPA auto-scaling, Service load balancing, rolling updates/rollbacks, DNS service discovery, intelligent scheduling.
Defined Kubernetes vs. Docker scope comparison — Docker is single-host runtime; Kubernetes is multi-host orchestration.
Documented when NOT to use Kubernetes: small single apps, one-off batch jobs, teams without DevOps expertise, edge/IoT constrained devices.
Created the Why Kubernetes? concept page with problem/solution tables, architecture diagram, and decision framework.
[2026-05-21] ingest | CKA Day 2: How To Dockerize a Project | Tech Tutorials with Piyush
Ingested Day 2 of the 40-day CKA course covering practical Dockerization — writing Dockerfiles, building images, and running containerized applications.
Documented the Dockerfile instruction reference (FROM, WORKDIR, COPY, RUN, EXPOSE, ENV, USER, CMD, ENTRYPOINT) with purposes and examples.
Synthesized the Dockerize workflow: .dockerignore → Dockerfile → docker build → docker run → docker push.
Explained layer caching optimization — copying dependency files before source code to maximize cache hits.
Covered multi-stage builds for smaller production images and reduced attack surface.
Catalogued common pitfalls: missing .dockerignore, using latest tag, running as root, hardcoded config, ignoring signals, large images.
Created the Dockerize a Project concept page with full Dockerfile examples, optimization patterns, and troubleshooting table.
Explained the Docker-Kubernetes relationship — Kubernetes uses containerd (a CRI) under the hood; Docker fluency is essential for debugging pods via kubectl.
Created the Docker Fundamentals concept page with architecture diagrams, command tables, and lifecycle flow.
Created the 40-day study roadmap broken into 4 phases: Foundation (Days 0–10), Workloads/Networking/Storage (Days 11–25), Security/Scheduling/Troubleshooting (Days 26–35), Mock Exams (Days 36–40).
Documented the daily study methodology: Watch → Lab → Note → Quiz → Log.
Created the CKA Certification concept page with exam details and resources.
Created the CKA Study Roadmap concept page with day-by-day schedule.
[2026-05-15] ingest | Claude + MCP Explained | CampusX
Ingested CampusX’s practical deep dive into MCP server integration with Claude Code — significantly different from the earlier architectural overview.
Documented the Top 10 MCP Servers catalog: SQLite (natural language DB queries), Figma (design-to-code), GitHub (PR automation), Context7 (live docs), Jira, Notion, Slack, AWS, Docker.
Synthesized the MCP context bloat anti-pattern — each server loads tool descriptions into context at session start; too many servers degrade model performance.
Documented the Plugin architecture — bundles MCP servers + Skills + Agents + Hooks into a single installable package (demonstrated with Figma plugin).
Documented MCP management commands: /mcp for listing, claude mcp remove for cleanup, View Tools for capability inspection.
Documented GitHub PAT setup with fine-grained permissions and the PR write access gotcha.
Updated MCP with top 10 server catalog, context bloat warning, plugin architecture, management commands.
Updated Claude Code with MCP server list and context bloat note.
Updated Context Engineering with MCP context loading as automatic context injection.
Updated Claude Skills with plugin architecture explanation.