DevOps, Containers, Kubernetes & Cloud Infrastructure Master (50 Qs)

Give a candid introduction of your DevOps, Cloud Infrastructure, and Kubernetes experience.

Containers vs. Virtual Machines: How do Linux Namespaces and Control Groups (cgroups) isolate processes?

Container Storage & UnionFS / Overlay2: How does the Copy-on-Write (CoW) mechanism work in Docker?

How do you optimize Dockerfiles for minimum image size, security, and build layer caching in production?

Why is running containers as root a major security vulnerability, and how do you secure container runtime privileges?

Docker Networking: Bridge vs. Host vs. Overlay networks and how port mapping works under the hood.

Why do containers fail to handle SIGTERM/SIGINT when running as PID 1, and what is the Zombie Process Reaping problem?

Docker Compose in Production & Staging: Service dependencies, healthchecks, and volume management.

How do OCI Image Manifests, Multi-Architecture builds (Buildx), and Image Signing (Cosign) work?

How do you systematically debug an unhealthy or crashing container in production (Exit Code 137, 139, 1)?

Kubernetes Control Plane Architecture: How do Control Plane components and Worker Node agents interact?

The etcd Distributed Datastore: Raft consensus, quorum calculation, snapshot backups, and write latency.

Kube-API Server Request Lifecycle: Authentication, Authorization, Mutating and Validating Admission Controllers.

Kube-Scheduler Deep-Dive: How Filtering, Scoring, Node Affinity, Taints, and Tolerations place Pods.

Kubelet & Container Runtime Interface (CRI): syncLoop mechanics, Static Pods, and cgroup drivers.

Pod Lifecycle & State Machine: Pending, Running, Succeeded, Failed, and graceful shutdown sequencing.

Liveness, Readiness, and Startup Probes: Differences, failure thresholds, and avoiding probe death spirals.

Deployments vs. ReplicaSets vs. StatefulSets: When to use StatefulSets and how headless services work.

DaemonSets & Job/CronJob Controllers: Concurrency policies, node maintenance, and backoff limits.

ConfigMaps & Secrets: Volume mounts vs. environment variables, automatic reloading, and KMS encryption.

Persistent Volumes (PV), PVC, StorageClass, and the Container Storage Interface (CSI).

Kubernetes Networking Model & CNI: IP-per-Pod, Calico vs. Cilium (eBPF) vs. Cloud VPC CNI.

Kubernetes Services Architecture: ClusterIP, NodePort, LoadBalancer, and Kube-proxy iptables vs. IPVS.

Ingress Controllers vs. Kubernetes Gateway API: Architecture, TLS termination, and traffic routing.

Kubernetes Network Policies & Microsegmentation: Default deny-all security postures and multi-tier isolation.

Horizontal Pod Autoscaler (HPA) vs. Vertical Pod Autoscaler (VPA): Algorithms, KEDA custom metrics, and avoiding scaling conflicts.

Cluster Autoscaling & Karpenter: Kubernetes Cluster Autoscaler vs. Karpenter just-in-time node provisioning.

Resource Requests, Limits, and Quality of Service (QoS) Classes: Guaranteed vs. Burstable vs. BestEffort.

Pod Disruption Budgets (PDB): Protecting high availability during voluntary disruptions and node drains.

Zero-Downtime Rolling Updates: maxSurge, maxUnavailable, readiness gates, and preStop socket draining.

Service Mesh Architecture: When to adopt Istio vs. Linkerd, sidecar injection vs. Ambient Mesh, and mTLS.

Kubernetes RBAC: Roles, ClusterRoles, ServiceAccounts, and least-privilege token protection.

Custom Resource Definitions (CRDs) & The Operator Pattern: The Reconcile Loop in Go/controller-runtime.

How do you systematically troubleshoot CrashLoopBackOff, ImagePullBackOff, and Pending Pods?

Multi-Tenant Cluster Isolation: ResourceQuotas, LimitRanges, NetworkPolicies, and Virtual Clusters (vcluster).

CI vs. CD vs. Continuous Deployment: Core principles, Trunk-Based Development, and deployment gates.

Building Secure CI/CD Pipelines: GitHub Actions layer caching, ephemeral runners, and OIDC keyless authentication.

GitOps Philosophy & ArgoCD / Flux: Declarative state, pull-based reconciliation, and automated drift remediation.

Progressive Delivery & Release Strategies: Blue/Green vs. Canary vs. Shadow / Mirroring with Argo Rollouts.

Helm Packaging vs. Kustomize: Template rendering vs. overlay patching and secret handling.

Software Supply Chain Security & SLSA Framework: SBOM generation, container scanning (Trivy), and SAST.

Zero-Downtime Database Migrations in CI/CD: The Expand-and-Contract (Parallel Run) migration pattern.

Infrastructure as Code (IaC): Terraform state architecture, remote backends, and state locking mechanisms.

Terraform Modules, Multi-Environment Architecture, and Automated Configuration Drift Detection.

Site Reliability Engineering (SRE): SLI vs. SLO vs. SLA, Error Budgets, and Burn Rate alerting.

The Three Pillars of Observability: Metrics, Structured Logs, and Distributed Tracing (OpenTelemetry).

Prometheus Architecture & PromQL Fundamentals: Pull-based scraping, TSDB storage, and essential PromQL queries.

Grafana Dashboard Engineering & Alert Fatigue Prevention: The Four Golden Signals and Alertmanager tuning.

Production Incident Management & Blameless Post-Mortems: Roles, war rooms, 5-Whys, and corrective actions.

How do you summarize your engineering philosophy and conclude a DevOps / Platform / SRE Interview?