Kubernetes Architecture

Introduction

Kubernetes, often abbreviated as K8s, is an open-source platform designed to automate deploying, scaling, and operating application containers. It was originally developed by Google and is now maintained by the Cloud Native Computing Foundation (CNCF). Kubernetes provides a portable, extensible runtime for deploying, managing, and scaling containerized applications.

In this tutorial, we will explore the architecture of Kubernetes, understand its key components, and see how they work together to manage containerized applications efficiently. This knowledge will be essential for anyone looking to deploy and manage applications in a containerized environment using Kubernetes.

Concept

Kubernetes is designed around the concept of managing "pods," which are groups of one or more containers that share storage and network resources. The architecture of Kubernetes can be broken down into several key components:

1. Control Plane: This is the brain of the Kubernetes cluster, responsible for making global decisions about the cluster (e.g., scheduling applications) and changing the state of the cluster when necessary.
2. Worker Nodes: These are the machines where your containerized applications run. Each worker node in the cluster runs processes called "kubelet" and a container runtime (like Docker).
3. ETCD: This is a highly-available key-value store that Kubernetes uses to store all of its configuration data.

Control Plane Components

The control plane consists of several components:

• API Server: The front-end for the Kubernetes control plane, exposing the Kubernetes API.
• Scheduler: Watches newly created pods with no node assigned and selects a node for them to run on based on constraints and available resources.
• Controller Manager: Runs controller processes which regulate the state of the cluster. Examples include replication controllers, endpoints controllers, namespace controllers, etc.
• ETCD: Stores all the configuration data for the Kubernetes cluster.

Worker Node Components

Each worker node in a Kubernetes cluster runs several components:

• Kubelet: An agent that runs on each node and ensures that containers are running as specified by their corresponding Pods.
• kube-proxy: Provides network proxying (load balancing) for TCP and UDP, and performs simple NAT for IP translation.
• Container Runtime: The software responsible for running container images. Examples include Docker, containerd, CRI-O.

Examples

Let's walk through a practical example to understand how Kubernetes architecture works in action.

Step 1: Setting Up a Local Cluster

First, you need to set up a local Kubernetes cluster. For this example, we will use minikube, which is a tool that makes it easy to run a single-node Kubernetes cluster inside a VM on your laptop for development and testing purposes.

deployment.apps/nginx-deployment created

Step 3: Exposing the Application

To access our Nginx application from outside the cluster, we need to expose it using a service.

1apiVersion: v1
2kind: Service
3metadata:
4name: nginx-service
5spec:
6selector:
7  app: nginx
8ports:
9  - protocol: TCP
10    port: 80
11    targetPort: 80
12type: LoadBalancer

Save this YAML file as nginx-service.yaml. Then, apply the service using kubectl.

http://192.168.49.2:30007

Open this URL in your web browser, and you should see the Nginx welcome page.

What's Next?

In this tutorial, we covered the basic architecture of Kubernetes and how to set up a local cluster using minikube. We also deployed a simple application and exposed it to the outside world. In the next section, we will dive deeper into deploying applications on Kubernetes, including more advanced configurations and best practices.