Understanding Kubernetes and Its Role with Docker

In this article, we will explore the essential concepts of Kubernetes and Docker, two pivotal technologies in the realm of containerization. We will discuss what Kubernetes is, its architecture, and its relationship with Docker. Additionally, we will cover the advantages and disadvantages of using Docker, the types of Kubernetes clusters, and practical commands for installing and deploying applications in Kubernetes. By the end of this article, you will have a clearer understanding of how these technologies work together to enhance application deployment and management.

What is Docker with Kubernetes?

Docker is an open-source container orchestration platform. It helps automate the deployment, scaling, and management of containerized applications. Docker revolutionized the way we build and deploy applications by packaging them into containers, but Kubernetes takes it a step further by managing the containers across multiple servers (or clusters).

Another Name for Kubernetes

Kubernetes is often abbreviated as K8s, where the "8" represents the eight letters between the "K" and the "s."

Docker with Kubernetes:

Docker serves as the platform for building and packaging applications into containers (the ship), while Kubernetes orchestrates and manages those containers at scale (the steering wheel), ensuring they run efficiently across clusters of servers.

• How They Work Together

Docker is a platform used to develop, ship, and run applications inside containers. It enables developers to package their applications with all dependencies into a single, lightweight container.

When Docker is combined with Kubernetes, you get a powerful system that not only packages and isolates your applications (Docker) but also manages the deployment, scaling, and monitoring of these containers (Kubernetes).

• Docker: Manages the creation and operation of containers.
• Kubernetes: Manages and orchestrates a group (or cluster) of Docker containers.

Disadvantages of Using Docker Alone:

While Docker is a powerful tool, it has its limitations, especially when used in larger, distributed environments. Some of the key disadvantages are:

1. No Rollback to a Specific Version: Docker does not provide built-in rollback functionality for container versions.
2. No Autoscaling: Docker by itself does not support automatic scaling of containers.
3. Limited Community Support for Orchestration: While Docker has excellent community support for containerization, its orchestration (e.g., Docker Swarm) is less popular than Kubernetes.
4. Setup Complexity: Managing containers across distributed environments without an orchestrator like Kubernetes can be complex.
5. No Native GUI: Docker does not have a built-in graphical interface for management.
6. Docker Swarm Limitations: Docker Swarm (its native orchestration tool) lacks some advanced features like self-healing and autoscaling.

Advantages of Kubernetes (K8s):

• Autoscaling: Automatically scale applications up or down based on demand.
• Self-Healing: Restarts failed containers and replaces unresponsive nodes.
• Automated Rollouts and Rollbacks: Manages updates and rolls back to previous versions if something goes wrong.
• Extensive Community Support: Kubernetes has a large community of contributors, making it a very popular and robust solution.
• Multi-cloud Support: Kubernetes can run on various environments, including on-premises, public clouds, or hybrid cloud environments.

Kubernetes Architecture

Understanding Kubernetes' architecture is essential to grasp how it manages applications. Below are the critical components of Kubernetes:

Kubernetes Primary (Master Node):

The main control unit that manages the cluster.

• API Server: The front-end interface of Kubernetes, responsible for exposing APIs to interact with the cluster.
• Controller Manager: Ensures that the desired state of the cluster is maintained by managing tasks like node and pod lifecycle, replication, and more.
• Scheduler: Assigns pods to specific nodes based on resource availability.
• etcd: A distributed key-value store that stores all cluster configuration data.2

Kubernetes Node:

A worker machine in Kubernetes where containers are deployed.

• Kubelet: An agent that runs on each node and ensures containers are running correctly.
• cAdvisor: Monitors resource usage and performance metrics of containers.
• Kube-proxy: Handles network traffic routing between containers inside the cluster.
• Pods: The smallest deployable units that contain one or more containers. Kubernetes manages containers within pods, and each pod runs on a node.

What is a Cluster?

A cluster is a group of servers (nodes) that work together to run applications. There are two main types of clusters:

Self-Managed Cluster: A cluster managed by the user, where they handle the installation and maintenance of Kubernetes components.

• Minikube: A single-node cluster for local development.
• Kubeadm: A multi-node cluster for initializing Kubernetes clusters.
• Kops: A multi-node cluster for managing Kubernetes clusters on AWS.

Cloud-Managed Cluster: A cluster provided and maintained by cloud providers (e.g., Google Kubernetes Engine, Amazon EKS).

• AWS EKS: Amazon Elastic Kubernetes Service.
• Azure AKS: Azure Kubernetes Service.
• Google GKE: Google Kubernetes Engine.
• IBM IKS: IBM Kubernetes Service.

What are Controllers?

Controllers in Kubernetes are responsible for managing the state of the cluster. Some common types include:

• Replication Controller: Ensures the desired number of pod replicas are running.
• Node Controller: Monitors the status of nodes and handles node failures.
• Service Controller: Manages service endpoints and ensures they are reachable.

Monitoring and Grace Periods

Kubernetes controllers periodically monitor the cluster state (5 sec), checking whether the actual state matches the desired state. If discrepancies are found, the controller takes action to correct them.

The grace period is the time (40 sec) Kubernetes waits before taking action on a failing resource, allowing for temporary issues to resolve.

What is Minikube?

Minikube is a tool that allows you to run Kubernetes locally on a single-node cluster. It is particularly useful for developers who want to experiment with Kubernetes without needing a full multi-node setup.

Types of Kubernetes Installation

1. Imperative: Directly executes commands to create or manage resources.
2. Declarative: Uses configuration files (YAML) to define the desired state of the resources.

Commands to Install Minikube

To install Minikube, you can follow these steps:

apt update -y

sudo apt install curl wget apt-transport-https -y

sudo curl -fsSL https://get.docker.com -o get-docker.sh

sudo sh get-docker.sh

sudo curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

sudo mv minikube-linux-amd64 /usr/local/bin/minikube

sudo chmod +x /usr/local/bin/minikube

sudo minikube version

sudo curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

sudo curl -LO "https://dl.k8s.io/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256"

sudo echo "$(cat kubectl.sha256) kubectl" | sha256sum --check

sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

sudo minikube start --driver=docker --force

Deploying an Application in Kubernetes

To deploy an application, you need to create a pod using the following command:

kubectl run podname --image=imagename

Listing Pods

To view the list of running pods, use the following command:

kubectl get pods

Declarative Way to Create a Pod

You can create a pod using a YAML file (pod.yml) with the following content:

---

apiVersion: v1

kind: Pod

metadata:

name: mypod

spec:

containers:

- name: cont1

image: nginx

ports:

- containerPort: 80

To create the pod, run:

kubectl create -f pod.yml