Kubernetes in Practice: From First Pod to Production Troubleshooting

Build practical Kubernetes skills by deploying an application, exposing it through Services, and managing configuration, resources, and rollouts. Learn to diagnose common workload and networking failures using a repeatable troubleshooting workflow. Apply these skills in a compact capstone focused on operating and recovering an application, with cloud-neutral examples.

Level: intermediate · 24 lessons · about 8 h · Free · AI-assisted course created by Sandip Das

What you will learn

• Explain how Kubernetes control-plane components, worker nodes, and core API objects support an application.
• Deploy and update an application using Pods, Deployments, declarative manifests, and kubectl.
• Configure Service discovery, application configuration, secrets, and basic persistent storage.
• Set resource requests and limits, health probes, and basic access controls for safer application operation.
• Diagnose pending Pods, crashes, image pull failures, and Service connectivity issues using events, logs, and targeted checks.
• Complete a capstone that deploys an application, introduces failures, and documents verified recovery steps.

Course outline

1. Understand the Cluster and Work Safely

Connect Kubernetes architecture to application behavior and establish a safe, declarative workflow in a disposable practice cluster.

1. From API Request to Running Application (15 min) · free preview
   Use an architecture diagram to trace desired state through the API server, backing store, scheduler, controllers, and node agents.
2. Verify Your Practice Environment (20 min)
   Use an available disposable local cluster or authorized practice namespace without teaching cluster provisioning, and check context, namespace, permissions, and version compatibility.
3. Read, Validate, Diff, and Apply Manifests (20 min)
   Refresh essential YAML and learn the relationship between manifest fields, desired state, live state, validation, and declarative updates.
4. Run and Inspect Your First Pod (25 min)
   Apply a small Pod manifest using a verified image reference, inspect its lifecycle, and remove only the practice resource.

2. Deploy an Application and Make It Reachable

Move from a bare Pod to a managed application and trace client traffic through labels, Services, DNS, and optional Ingress.

1. Manage Replicas with Deployments (25 min)
   Create a Deployment and inspect how selectors, Pod-template labels, ReplicaSets, and owner references connect managed resources.
2. Connect Clients with a Service (25 min)
   Configure a ClusterIP Service and map its selector, port, targetPort, and EndpointSlices to application Pods.
3. Test Service Discovery and Debugging Access (20 min)
   Resolve a Service from an in-cluster client and compare that path with a loopback-only workstation port-forward.
4. Choose an Application Exposure Path (10 min)
   Introduce NodePort, LoadBalancer, and HTTP Ingress without installing infrastructure or assuming that a controller already exists.

3. Separate Configuration, Secrets, and Data

Configure an application without rebuilding its image and introduce persistent storage with explicit provisioning and cleanup assumptions.

1. Configure Applications with ConfigMaps (25 min)
   Compare selected environment variables and projected files, including when application reloads or Pod replacement are needed.
2. Use Secrets Without Treating Encoding as Security (20 min)
   Use non-sensitive practice values to wire Secret references while keeping credentials out of repositories, command output, and shared evidence.
3. Request Storage and Verify Persistence (25 min)
   Read available StorageClasses, create a small PVC-backed practice workload, and distinguish Pod lifetime from storage lifetime without configuring storage infrastructure.
4. Validate Configuration and Storage Together (10 min)
   Complete a short guided checkpoint that verifies configuration references and mounted data without exposing Secret values or assuming every cluster has a default StorageClass.

4. Control Resources, Health, and Releases

Make application operation safer with resource budgets, meaningful health checks, deliberate replica counts, and reversible releases.

1. Set Requests and Limits Deliberately (20 min)
   Read CPU and memory quantities, configure resource budgets, and separate scheduling requirements from runtime enforcement.
2. Choose Health Probes That Match the Application (25 min)
   Configure health checks and observe how startup, readiness, and liveness affect restarts and Service traffic differently.
3. Scale Replicas Without Losing Desired State (15 min)
   Scale a Deployment, inspect desired and available replicas, and reconcile manual scaling with the checked-in manifest.
4. Release, Observe, and Roll Back (20 min)
   Use verified image references to perform a controlled rolling update, inspect revision history, and recover from a stalled release.

5. Apply Basic Security and Diagnose Container Failures

Introduce least-privilege workload operation and a repeatable evidence-first workflow for image and runtime failures.

1. Give Workloads Only the Access They Need (20 min)
   Connect ServiceAccounts, Roles, and RoleBindings and verify both allowed and forbidden actions with appropriate authorization.
2. Harden a Compatible Workload (20 min)
   Apply introductory Linux container safeguards without expanding into cluster-wide policy administration.
3. Build a Repeatable Troubleshooting Record (20 min)
   Follow a symptom-to-hypothesis workflow using status, describe, namespaced events, current and previous logs, and narrowly scoped exec when available and authorized.
4. Separate Image Pull Failures from Application Crashes (20 min)
   Diagnose a deliberately broken image reference and a crashing container, then distinguish bad startup configuration, OOM termination, and probe-induced restarts.

6. Resolve Scheduling and Connectivity Failures, Then Prove Recovery

Practice targeted infrastructure-adjacent checks and finish with a compact application deployment, fault-injection, and documented recovery capstone.

1. Explain Why a Pod Is Pending (20 min)
   Distinguish resource-fit and placement problems from unbound storage and other startup blockers, without treating Pending as a single diagnosis.
2. Trace a Failed Request End to End (20 min)
   Work from DNS and Service configuration through selected Pods, EndpointSlices, readiness, and the application listener, using port-forward only as a diagnostic comparison.
3. Capstone: Build and Verify the Operating Baseline (20 min)
   Assemble the practiced application manifests in a disposable namespace, including a Deployment, Service, configuration, dummy Secret, resource budgets, probes, and basic workload security; reuse the storage checkpoint when provisioning is available.
4. Capstone: Inject Failures and Demonstrate Recovery (20 min)
   Introduce a bad image rollout and a Service selector mismatch one at a time, recover using the evidence-first workflow, and produce a concise incident record plus cleanup verification.

Start the course on LearnXops