Day 37: Kubernetes Important interview Questions.

1. What is Kubernetes and why it is important?

Kubernetes is an open-source platform for automating the deployment, scaling, and management of containerized applications. It provides a unified way to manage and orchestrate containers, making it easier to build, deploy, and manage complex applications at scale.

Kubernetes is important because it enables organizations to efficiently manage large-scale, highly-available, and scalable applications. It helps developers to easily build, deploy, and manage their applications in a scalable and efficient manner. Kubernetes provides features like self-healing, and horizontal scaling, which make it easier for organizations to adopt container technologies.

2. What is the difference between docker swarm and Kubernetes?

Docker Swarm is a native clustering solution for Docker that provides load balancing and orchestration of containers. Docker Swarm is simpler and easier to use, making it a good choice for smaller or less complex deployments. Kubernetes, on the other hand, is a more comprehensive platform that provides a range of features and functionalities, including auto-scaling, self-healing, rollbacks, and rolling updates. Additionally, Kubernetes has a much larger user base and a more active development community, making it a more popular choice for large-scale production deployments.

3. How does Kubernetes handle network communication between containers?

Kubernetes provides a virtual network for containers to communicate with each other. This virtual network allows containers within the same pod to communicate using local IP addresses, and allows communication between pods using their own IP addresses, even if they are running on different nodes. Kubernetes also provides built-in service discovery and load balancing to distribute incoming traffic to services among the pods running the service.

4. How does Kubernetes handle scaling of applications?

Autoscaling is when you configure your application to automatically adjust the number of pods based on current demand and resource availability. If too few pods are running, the system could automatically create more pods to meet demand. On the other hand, you can also scale down if there are too many pods. There are three types of autoscaling in Kubernetes - Horizontal Pod Autoscaler, Vertical Pod Autoscaler and Cluster Autoscaler.

Kubernetes provides several mechanisms for scaling applications, including Horizontal Pod Autoscaler (HPA), which automatically scales the number of replicas of a Deployment, ReplicaSet, or StatefulSet based on resource utilization, and Vertical Pod Autoscaler (VPA), which automatically scales the resource requests and limits of containers. Kubernetes also supports manual scaling using the kubectl command-line tool or the Kubernetes API. Additionally, Kubernetes provides cluster-level autoscaling for the underlying infrastructure using features such as Cluster Autoscaler and Node Autoscaler.

5. What is a Kubernetes Deployment and how does it differ from a ReplicaSet?

A Deployment is a higher-level object that provides declarative updates for Pods and ReplicaSets. It is responsible for managing the desired state of a set of Pods and coordinating their updates. Deployments are designed to support rolling updates, which means that you can update your application without incurring downtime or disrupting the running services. Deployments use a ReplicaSet to create and manage the Pods. Deployment is a higher-level abstraction that provides more advanced features, such as rolling updates, while a ReplicaSet is a simpler and lower-level abstraction that focuses on ensuring that the desired number of replicas are running.

6. Can you explain the concept of rolling updates in Kubernetes?

A rolling update in Kubernetes is a deployment strategy that gradually replaces the old instances of an application with new ones in a controlled and predictable way, without causing downtime or disrupting the running services. Kubernetes creates a new ReplicaSet with the updated version of the application, gradually scales up the new instances while scaling down the old ones, and ensures that the new instances are ready and healthy before terminating the old ones. Rolling updates allow for continuous delivery and predictable, controlled updates.

7. How does Kubernetes handle network security and access control?

Kubernetes allows you to define network policies that control the traffic between pods and services. You can use network policies to allow or deny traffic based on various criteria, such as IP addresses, ports, and protocols. Kubernetes uses service accounts to provide access control to the Kubernetes API and other resources. Service accounts are assigned to pods and provide a way to authenticate and authorize access to resources.

Kubernetes provides RBAC to control access to Kubernetes resources. You can define roles and role bindings to control who can perform specific actions on resources. Kubernetes provides a way to store and manage sensitive data, such as passwords and API keys, using secrets. Secrets are encrypted and can be accessed only by authorized users. Kubernetes provides runtime security features, such as container image scanning, to detect and prevent security vulnerabilities and exploits in container images.

Kubernetes supports network encryption using Transport Layer Security (TLS) to secure communication between components and services. Kubernetes allows you to define ingress controllers to control access to services from outside the cluster.

8. Can you give an example of how Kubernetes can be used to deploy a highly available application?

For example, To ensure high availability, we can use Kubernetes to deploy multiple replicas of each microservice, and use Kubernetes features like ReplicaSets and StatefulSets to ensure that the desired number of replicas are always running. We can also use Kubernetes built-in load balancing and service discovery to route traffic to healthy replicas and perform automatic failover in case of a failure. Additionally, we can use Kubernetes' persistent volume feature to ensure data durability, so that even if a pod fails and gets replaced, the data stored in the persistent volume will still be available to the new pod. we can ensure that our application is highly available, resilient to failures, and can scale up or down as needed to handle changing traffic loads.

9. What is namespace is kubernetes? Which namespace any pod takes if we don't specify any namespace?

In Kubernetes, a namespace is a virtual cluster that provides a way to partition resources and manage access to those resources. By default, Kubernetes comes with four namespaces: "default", "kube-system", "kube-public", and "kube-node-lease". When we create a pod without specifying a namespace, it is created in the "default" namespace by default.

10. How ingress helps in kubernetes?

In Kubernetes, Ingress is a way to manage external access to services running inside the cluster. It routes traffic based on the request's host name and path, and can also provide SSL/TLS termination, load balancing, path-based routing, URL rewriting, and authentication/authorization. It's a powerful tool that enables you to manage external traffic to your services, and provides several advanced features for traffic management and security.

11. Explain different types of services in kubernetes?

In Kubernetes, there are four types of services:

ClusterIP: provides a stable IP address for internal communication within the cluster.

NodePort: exposes a service on a static port on each worker node for access from outside the cluster.

LoadBalancer: exposes a service outside the cluster using a cloud provider's load balancer for public-facing applications.

ExternalName: maps a service to a DNS name to reference an external service by name instead of IP address.

12. Can you explain the concept of self-healing in Kubernetes and give examples of how it works?

In Kubernetes, self-healing refers to the ability of the system to detect and recover from failures automatically. This is achieved through the use of various features and components, including

Replication: Kubernetes can automatically create new instances of a failed pod or container to maintain the desired number of replicas. This ensures that the application continues to function even if individual components fail.

Health checks: Kubernetes uses health checks to monitor the status of pods and containers, and can automatically remove or replace instances that are not responding correctly.

Probes: Kubernetes provides different types of probes, such as liveness and readiness probes, to check the health and availability of pods and containers.

Rolling updates: Kubernetes can update an application by gradually replacing old instances with new ones. If a problem is detected, Kubernetes can automatically roll back the update to the previous version.

For example, suppose a pod fails due to a hardware failure or a software issue. In that case, Kubernetes can automatically replace the failed pod with a new instance, ensuring that the application continues to function as expected. These automatic recovery mechanisms ensure that the application remains available and responsive even in the face of unexpected failures.

13. How does Kubernetes handle storage management for containers?

Kubernetes provides several mechanisms for storage management that enable containers to store and access data. Here are some of the storage options available in Kubernetes:

Volumes: Volumes are the simplest way to provide persistent storage for a container in Kubernetes. A volume is a directory that is accessible to all containers running in a pod. Kubernetes supports several types of volumes, including emptyDir, hostPath, and persistentVolumeClaim (PVC).

Persistent Volumes: Persistent Volumes (PVs) are cluster-wide resources that can be dynamically provisioned or statically created by a cluster administrator. PVs are independent of pods and can be mounted by any pod that needs it.

Persistent Volume Claims: A Persistent Volume Claim (PVC) is a request for storage by a pod. A PVC is used to bind a pod to a specific PV. When a PVC is created, Kubernetes finds a matching PV and binds the two together.

14. How does the NodePort service work?

In Kubernetes, a NodePort service is a way to expose a service on a specific port on all the nodes in the cluster. When you create a NodePort service, Kubernetes assigns a static port (between 30000 and 32767) to the service. Kubernetes creates a new service object that maps the static port to the target port of the pods that the service is selecting. When a client sends a request to the static port of any node in the cluster, the request is forwarded to the service and then to one of the pods selected by the service. The response from the pod is sent back to the client through the same node and port. The NodePort service type is often used to expose services that need to be accessible from outside the cluster, such as web applications.

15. What is a multinode cluster and single-node cluster in Kubernetes?

A single-node cluster is a Kubernetes cluster that runs on a single physical or virtual machine. In a single-node cluster, all the Kubernetes components run on the same node, including the API server, etcd database, and worker node, while a multi-node cluster is a Kubernetes cluster that runs on multiple physical or virtual machines. In a multi-node cluster, the Kubernetes components are distributed across multiple nodes, with each node performing a specific role. For example, one node may be the control plane node, while the other nodes are worker nodes.

16. Difference between create and apply in kubernetes?

In Kubernetes, "create" and "apply" are two commands that can be used to create or modify Kubernetes objects, such as pods, services, or deployments. When you use “create”, Kubernetes will create a new resource based on the definition provided in the YAML file. When you use “apply”, Kubernetes will compare the current state of the resource with the definition provided in the YAML file and make any necessary changes to bring the resource into the desired state.

Thank you for reading!! Hope you find this helpful.

#day37challenge#90daysofdevops

Always open to suggestions..!!

~ Manoj Bhamidipati 🙂