Key Concepts

• Pods
• Deployments
• Services

Concept Deep Dive

Pods

Pods is a core idea you’ll use repeatedly while working with Kubernetes.

Why it matters: Understanding Pods helps you design safer workflows and troubleshoot issues faster.

Practice:

• Explain Pods in your own words (1 minute rule).
• Find where Pods appears in real docs/configs for Kubernetes.
• Create a small example that uses Pods, then break it and fix it.

Deployments

Deployments is a core idea you’ll use repeatedly while working with Kubernetes.

Why it matters: Understanding Deployments helps you design safer workflows and troubleshoot issues faster.

Practice:

• Explain Deployments in your own words (1 minute rule).
• Find where Deployments appears in real docs/configs for Kubernetes.
• Create a small example that uses Deployments, then break it and fix it.

Services

Services is a core idea you’ll use repeatedly while working with Kubernetes.

Why it matters: Understanding Services helps you design safer workflows and troubleshoot issues faster.

Practice:

• Explain Services in your own words (1 minute rule).
• Find where Services appears in real docs/configs for Kubernetes.
• Create a small example that uses Services, then break it and fix it.

Core Workflow

1. Foundations

Start with core Kubernetes concepts and basic setup so you can use it safely in day-to-day work.

Goals:

• Understand Kubernetes fundamentals
• Set up local/dev environment
• Run first working example

2. Team Workflow

Integrate Kubernetes into real team practices with repeatable conventions and collaboration patterns.

Goals:

• Adopt standards and naming conventions
• Integrate with repositories and CI/CD
• Create reusable templates

3. Production Operations

Use Kubernetes in production with observability, security, and rollback plans.

Goals:

• Monitor behavior and failures
• Secure access and secrets
• Define incident and rollback flow

4. Scale and Optimization

Continuously improve reliability, performance, and cost while standardizing usage across services.

Goals:

• Improve performance and cost
• Automate compliance checks
• Document best practices for the team

Quick Start

1. Check cluster

kubectl cluster-info

1. Apply manifest

kubectl apply -f deployment.yaml

1. Watch pods

kubectl get pods -w

Tutorial Series

A tutorial-style sequence (like a handbook). Do these in order to build skill from beginner to production.

Tutorial 1: Build Your First Image

Goal: Package an app and run it in a container reliably.

Steps:

1. Verify you understand what the tool does and what problem it solves.
2. Install or enable it on your machine (or in a sandbox environment).
3. Run the smallest working example and write down what happened.
4. Build an image and run it locally.
5. Expose a port and verify it responds.

Checkpoints:

• You know image vs container
• You can map ports and read logs

Exercises:

• Reduce image size (multi-stage, slim base)
• Add a health check

Tutorial 2: Volumes and Persistence

Goal: Keep data safe across container restarts.

Steps:

1. Create a named volume and mount it.
2. Restart the container and confirm data remains.

Checkpoints:

• You understand what is ephemeral vs persistent
• You can inspect volumes

Exercises:

• Back up a volume to a tar file
• Restore the volume into a new container

Tutorial 3: Networking and Debugging

Goal: Debug common container issues: DNS, ports, env vars.

Steps:

1. Break one thing intentionally and practice debugging from logs/output.
2. Write a short checklist: what to check first, second, third.
3. Inspect networking and resolve a name (service discovery/DNS).
4. Exec into a container and validate environment variables.

Checkpoints:

• You can identify why a container cannot reach a dependency
• You can debug crash loops quickly

Exercises:

• Build a compose with app + db
• Write a checklist for container startup failures

Command Cheatsheet

• kubectl version --client: Show kubectl version.
• kubectl config get-contexts: List contexts.
• kubectl config current-context: Show current context.
• kubectl config use-context <ctx>: Switch cluster context.
• kubectl get ns: List namespaces.
• kubectl get all -n default: List core resources in namespace.
• kubectl get pods -n <ns> -o wide: Pods with nodes/IPs.
• kubectl get deploy -n <ns>: List deployments.
• kubectl get svc -n <ns>: List services.
• kubectl apply -f k8s.yaml: Apply manifests (create/update).
• kubectl delete -f k8s.yaml: Delete resources from manifest.
• kubectl rollout status deploy/<name> -n <ns>: Check rollout progress.
• kubectl rollout history deploy/<name> -n <ns>: Show rollout history.
• kubectl rollout undo deploy/<name> -n <ns>: Rollback to previous revision.
• kubectl describe pod <pod> -n <ns>: Detailed pod info and events.
• kubectl get events -n <ns> --sort-by=.metadata.creationTimestamp: Namespace events (time-sorted).
• kubectl logs <pod> -n <ns>: Read pod logs.
• kubectl logs -f <pod> -n <ns>: Follow logs.
• kubectl logs <pod> -c <container> -n <ns>: Logs for a specific container.
• kubectl exec -it <pod> -n <ns> -- sh: Open pod shell.
• kubectl port-forward svc/<svc> 8080:80 -n <ns>: Forward local port to service.
• kubectl set image deploy/<name> <container>=repo/img:tag -n <ns>: Update container image.
• kubectl scale deploy/<name> --replicas=3 -n <ns>: Scale deployment.
• kubectl top pods -n <ns>: Pod CPU/mem (metrics server).
• kubectl top nodes: Node CPU/mem (metrics server).

Learning Path

• Core objects
• Production deployments
• Troubleshooting

Beginner To Advanced Path

Beginner Path (Foundations)

What to learn:

• Learn Kubernetes terminology and the “why” behind it
• Install/setup and run a first working example
• Understand the main components and the default workflow
• Learn safe debugging: where to look when something fails
• Build a small checklist for your own repeatable setup
• Write notes (commands, errors, fixes) while learning

Hands-on labs:

• Follow a hello-world style tutorial and document every step
• Break one config intentionally and fix it (learn error patterns)
• Write a 10-command cheat sheet you can reuse later
• Create a simple diagram of the tool’s flow in your own words

Milestones:

• You can explain the tool in 2 minutes
• You can reproduce a working setup from scratch
• You can troubleshoot the top 3 common failures
• You can share a clean quick-start with someone else

Intermediate Path (Real Workflows)

What to learn:

• Use the tool inside a realistic DevOps workflow
• Create reusable templates/configs and standard naming conventions
• Add security basics: secrets handling and least privilege
• Reduce toil: automate repeated steps and build confidence
• Make the workflow faster and safer (cache, validations, checks)
• Document the workflow as if onboarding a new teammate

Hands-on labs:

• Integrate it with a CI pipeline (lint/build/test/deploy style flow)
• Parameterize config for dev/stage/prod environments
• Create a runbook: steps to validate and roll back a change
• Add a preflight validation step that blocks unsafe changes

Milestones:

• You can onboard another person with your docs
• You can run the tool consistently across environments
• You can explain tradeoffs (speed vs safety, flexibility vs complexity)
• You can debug failures using logs/outputs without guesswork

Advanced Path (Production & Scale)

What to learn:

• Operate the tool safely in production with guardrails
• Add observability: metrics/logs/traces and meaningful alerts
• Optimize performance/cost and standardize across multiple services
• Design failure modes and recovery (rollback, restore, incident flow)
• Create upgrade strategy and test it (versioning, compatibility)
• Create ownership: docs, alerts, dashboards, and operational SLAs

Hands-on labs:

• Add policy checks (security scans, approvals, protected environments)
• Load test or scale test the workflow and measure bottlenecks
• Create an incident simulation and write a postmortem template
• Automate audits: drift checks, compliance checks, and reports

Milestones:

• You can detect failures quickly and recover safely
• You can maintain the setup long-term (upgrade strategy, docs, ownership)
• You can explain architecture decisions and alternatives
• You can standardize patterns across multiple services/teams

Hands-On Labs

Beginner Labs

• Build and run a Kubernetes container for a simple web app
• Expose ports correctly and verify health
• Mount a volume and verify persistence
• Debug a crash loop using logs and entrypoint changes

Intermediate Labs

• Create a multi-service compose setup (app + db)
• Implement multi-stage build and reduce image size
• Add non-root user and confirm permissions
• Add health checks and restart policies

Advanced Labs

• Benchmark startup time and optimize layers/caching
• Run vulnerability scanning and fix findings
• Add image signing / provenance (if your stack supports it)
• Build an incident playbook for container failures

Advanced Topics

• Layer caching strategy and reproducible builds
• Distroless/minimal base images and non-root runtime
• Multi-arch builds (amd64/arm64) and buildx
• Runtime security: seccomp, capabilities, read-only FS
• Production debugging patterns for Kubernetes

Production Patterns

• Multi-stage builds, pinned base images, minimal runtime images
• Non-root containers (when possible) + read-only filesystem patterns
• Health checks and proper signal handling
• Standard image tagging (git sha) and registry hygiene for Kubernetes
• Resource limits/requests in orchestrators

Real-World Scenarios

• Package an app with Kubernetes so it runs the same locally and in production.
• Optimize image size and caching to speed up builds and reduce costs.
• Debug a container crash: entrypoint, environment variables, ports, and logs.

Troubleshooting

• Reproduce the issue with the smallest possible example
• Check logs/output first, then configuration, then permissions/credentials
• Validate inputs (versions, environment variables, file paths, network access)
• Rollback to last known-good state if production is affected
• Write down the root cause and add a guardrail so it does not repeat

Runbook Templates

Use these templates to make your docs feel like real production documentation.

Deploy Runbook

• Purpose
• Preconditions (secrets, access, approvals)
• Steps to deploy (exact commands)
• Post-deploy verification (health checks)
• Rollback steps
• Owner and escalation

Incident Triage Runbook

• Impact assessment (who is impacted?)
• Current signals (errors, latency, saturation)
• Recent changes (deploys, config, infra)
• First checks (logs, health endpoints, dependencies)
• Mitigation steps (rate limiting, rollback, scale)
• Follow-up actions (postmortem, guardrails)

Checklist (Copy/Paste)

• What changed since it last worked?
• What do logs say at the exact failure time?
• Is the service reachable on the expected port and DNS?
• Are credentials/permissions valid?
• Is disk full, memory exhausted, or CPU pegged?
• Do we have a safe rollback plan and is it tested?

Security & Best Practices

• Never hardcode secrets in code or commits
• Use least privilege (roles, scopes, minimal permissions)
• Prefer reproducible builds/configs over manual steps
• Add validations before applying changes (lint/validate/plan/dry-run)
• Keep documentation and runbooks updated
• Version pin critical dependencies and plan upgrades

Common Error Patterns

Symptom

Container starts then exits immediately

Likely cause: Wrong command/entrypoint, missing env var, or app crash

Fix steps:

• Check container logs first
• Run an interactive shell and inspect files/env
• Confirm ports and startup command

Symptom

Image is huge and builds are slow

Likely cause: No multi-stage build, poor layer caching, copying too much

Fix steps:

• Use multi-stage builds
• Copy dependency manifests first to improve caching
• Add .dockerignore and prune dev deps in runtime

FAQ

What is Kubernetes used for?

Kubernetes is used to standardize and automate parts of delivery and operations so teams can ship faster and more reliably.

How long does it take to learn Kubernetes?

You can get productive in days with fundamentals, but production mastery comes from building workflows, debugging failures, and operating it over time.

What should I learn before Kubernetes?

Learn basic Linux + Git first, then follow the prerequisites section. Fundamentals make every advanced topic easier.

How do I use Kubernetes safely in production?

Add guardrails: least privilege, validation before apply/deploy, monitoring, and a tested rollback plan.

Common Mistakes

• Using defaults in production without security hardening
• Skipping monitoring and post-deployment validation
• No rollback strategy for failed changes
• Over-complex setup before mastering fundamentals

Production Readiness Checklist

• Access control and least privilege applied
• Secrets managed securely
• Monitoring and alerting enabled
• Rollback and recovery process tested
• Documentation updated for team onboarding

Mini Projects

• Build a small project that uses Kubernetes in a realistic workflow
• Write a checklist for production usage
• Create a troubleshooting runbook for common failures
• Create a one-page internal doc: setup, usage, debugging, rollback

Interview Questions

• Explain what Kubernetes is and where it fits in DevOps.
• Describe a real problem you solved using Kubernetes.
• What can go wrong in production, and how do you detect and recover?
• What is the difference between an image and a container?
• How do you reduce image size and speed up builds?
• How do you debug a container that crashes immediately?

References

• Official documentation
• Video learning