Kubernetes is an open-source container orchestration platform that automates deployment, scaling, and management of containerized applications. The main components include:
Master Node Components:

• API Server: Central management component that exposes the Kubernetes API
• etcd: Distributed key-value store that stores cluster state and configuration
• Controller Manager: Runs controllers that regulate cluster state
• Scheduler: Assigns pods to nodes based on resource requirements
  Worker Node Components:
• kubelet: Agent that communicates with the API server and manages pods
• kube-proxy: Network proxy that maintains network rules
• Container Runtime: Software that runs containers (Docker, containerd, CRI-O)

• Pod: The smallest deployable unit in Kubernetes, containing one or more containers that share storage and network. Pods are ephemeral and typically not created directly.
• Deployment: Higher-level abstraction that manages ReplicaSets and provides declarative updates to Pods. It ensures the desired number of pod replicas are running.
• Service: Abstraction that defines a logical set of Pods and provides stable networking. It enables communication between different parts of an application.
  Example:

# Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.20

Namespaces provide a way to partition cluster resources between multiple users or teams. They create virtual clusters within a physical cluster, enabling:

• Resource isolation: Separate environments (dev, staging, prod)
• Access control: Different permissions for different teams
• Resource quotas: Limit resource consumption per namespace
• Name scoping: Same resource names can exist in different namespaces

kubectl create namespace development
kubectl get pods --namespace=development

Service types determine how services are exposed:

1. ClusterIP (default): Internal cluster access only
2. NodePort: Exposes service on each node's IP at a static port
3. LoadBalancer: Exposes service externally using cloud provider's load balancer
4. ExternalName: Maps service to external DNS name

# NodePort Service
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  type: NodePort
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 8080
    nodePort: 30007

Systematic troubleshooting approach:

# Check pod status
kubectl get pods -o wide
# Describe pod for events
kubectl describe pod <pod-name>
# Check logs
kubectl logs <pod-name>
# Check previous container logs if restarting
kubectl logs <pod-name> --previous
# Check node resources
kubectl top nodes
kubectl describe node <node-name>

Common issues:

• Image pull errors: Check image name, registry access, secrets
• Resource constraints: Insufficient CPU/memory on nodes
• Configuration errors: Invalid environment variables, missing secrets
• Network issues: DNS resolution, service connectivity

Pod lifecycle phases:

1. Pending: Pod accepted by cluster but containers not yet created
2. Running: Pod bound to node, all containers created, at least one running
3. Succeeded: All containers terminated successfully
4. Failed: All containers terminated, at least one failed
5. Unknown: Pod state cannot be determined
   Additional states include init containers, readiness/liveness probes, and termination grace periods. Understanding this is crucial for troubleshooting deployment issues.