Kubernetes

Kubernetes is a container orchestration platform that automates the deployment, scaling, and management of containerized applications. Its architecture comprises several components, each with specific functionality:

1. Master Components:
   • kube-apiserver: This is the Kubernetes API server that exposes the Kubernetes API. It handles API requests for managing Kubernetes objects, such as pods, services, deployments, and more. All other components interact with the API server to perform their tasks.
   • etcd: etcd is a distributed key-value store used by Kubernetes to store all cluster data, including configuration details and the state of the cluster. It acts as the cluster's source of truth, ensuring consistency and high availability.
   • kube-scheduler: The scheduler is responsible for assigning pods to nodes based on resource requirements, quality of service requirements, and other constraints. It watches for newly created pods with no assigned node and selects an appropriate node for them.
   • kube-controller-manager: This component runs various controller processes that regulate the state of the cluster, such as node controller, replication controller, endpoint controller, and service account and token controller. Each controller ensures that the desired state of the cluster matches the actual state.
   • cloud-controller-manager (optional): For cloud-based Kubernetes deployments, this component interacts with the underlying cloud infrastructure to manage resources like load balancers, volumes, and networks.
2. Node Components:
   • kubelet: The kubelet is an agent that runs on each node in the cluster and ensures that containers are running in pods as expected. It receives pod specifications from the API server and manages the containers' lifecycle, including starting, stopping, and monitoring them.
   • kube-proxy: This component maintains network rules on each node, enabling communication between pods within the cluster and external clients. It performs network address translation (NAT) for pods and handles service discovery.
   • Container Runtime: Kubernetes supports various container runtimes, such as Docker, containerd, and CRI-O. The container runtime is responsible for pulling container images, creating and managing containers, and executing commands within containers.
3. Add-Ons:
   • DNS: Kubernetes provides a built-in DNS service for service discovery within the cluster. It assigns DNS names to Kubernetes services and maps them to the corresponding pod IP addresses.
   • Dashboard: The Kubernetes Dashboard is a web-based user interface for managing and monitoring Kubernetes clusters. It provides a graphical representation of cluster resources and allows users to deploy applications, troubleshoot issues, and view metrics.
   • Ingress Controller: An Ingress controller manages external access to services within the cluster. It routes incoming traffic based on rules defined in Ingress resources and can provide features like SSL termination, load balancing, and path-based routing.
   • Cluster Autoscaler: The Cluster Autoscaler automatically adjusts the size of the cluster by adding or removing nodes based on resource utilization and constraints. It ensures optimal resource allocation and scalability of the cluster.

These components work together to provide a robust and scalable platform for deploying and managing containerized applications in production environments. They enable features such as high availability, fault tolerance, scalability, and self-healing capabilities, making Kubernetes a popular choice for container orchestration.

1. Deployment:

Definition: A Deployment in Kubernetes is an object that manages a replicated application, ensuring that a specified number of pod replicas are running at any given time.

Use Cases:

• Managing and scaling stateless applications.
• Facilitating rolling updates and rollbacks.
• Ensuring high availability and fault tolerance.

Example YAML Configuration:

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:latest
        ports:
        - containerPort: 80

Top 5 Interview Questions:

1. What is a Kubernetes Deployment, and why is it used?
2. How does rolling deployment work in Kubernetes, and what are its benefits?
3. Explain the purpose of the selector field in a Deployment specification.
4. What strategies can you employ to update the image of a pod in a Deployment?
5. Describe the difference between a Deployment and a StatefulSet in Kubernetes.

Answers:

1. A Kubernetes Deployment is an object used to manage and scale stateless applications by ensuring a specified number of pod replicas are running.
2. Rolling deployment in Kubernetes updates pods in a controlled manner, ensuring minimal downtime by gradually replacing old pods with new ones.
3. The selector field in a Deployment specification is used to specify which pods are controlled by the Deployment. Pods that match the labels defined in the selector will be managed by the Deployment.
4. Strategies for updating the image of a pod in a Deployment include rolling updates, recreating pods, or using the kubectl set image command.
5. Deployments are suitable for stateless applications and handle scaling and updating pods. StatefulSets, on the other hand, are designed for stateful applications requiring stable, unique network identifiers and stable storage.

2. StatefulSet:

Definition: A StatefulSet in Kubernetes is an object used to manage stateful applications, providing stable, unique network identifiers, and stable storage.

Use Cases:

• Managing stateful applications like databases, key-value stores, or distributed systems.
• Requiring stable, unique identities for each pod.
• Needing persistent storage.

Example YAML Configuration: (Similar to Deployment, but with StatefulSet kind)

Top 5 Interview Questions:

1. What is a Kubernetes StatefulSet, and when would you use it instead of a Deployment?
2. How does Kubernetes ensure ordered deployment and scaling of StatefulSets?
3. What is a Headless Service, and how is it related to StatefulSets?
4. Can you scale down a StatefulSet to zero replicas? If yes, what happens to the associated PersistentVolumes?
5. Explain the concept of a PVC (PersistentVolumeClaim) in the context of StatefulSets.

Answers:

1. A StatefulSet is used to manage stateful applications in Kubernetes, providing stable, unique network identifiers, and stable storage. It's preferred over Deployment for applications that require stable identities and persistent storage.
2. Kubernetes ensures ordered deployment and scaling of StatefulSets by assigning a unique ordinal index to each pod and ensuring pods are started and terminated in a predictable order.
3. A Headless Service is a service without a cluster IP, allowing direct communication with individual pods. It's related to StatefulSets as it enables access to each pod by its stable network identity.
4. Yes, you can scale down a StatefulSet to zero replicas. When scaling down, Kubernetes deletes the associated Pods and their PersistentVolumes if reclaimPolicy is set to "Delete".
5. A PersistentVolumeClaim (PVC) is a request for storage by a pod in Kubernetes. In the context of StatefulSets, PVCs are used to claim persistent storage volumes for stateful applications.