Kubernetes | Tools And Frameworks | Edge Computing Tutorial

Introduction to Kubernetes

Kubernetes is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. Originally developed by Google, it is now maintained by the Cloud Native Computing Foundation (CNCF). Kubernetes is highly extensible and can work with various container runtimes such as Docker.

Setting Up Kubernetes

Before we dive into Kubernetes concepts, we need to set up a Kubernetes cluster. You can set up Kubernetes on various platforms such as Minikube for local development, or on cloud providers like AWS, GCP, and Azure.

Using Minikube

Minikube is a tool that lets you run Kubernetes locally. It creates a virtual machine on your local machine and deploys a simple Kubernetes cluster.

Install Minikube and start a Kubernetes cluster:

$ minikube start

Kubernetes Architecture

Kubernetes follows a master-slave architecture. The master node is responsible for managing the cluster, while the worker nodes run the containerized applications.

Master Node Components

API Server: The front-end for the Kubernetes control plane.
etcd: A key-value store used for storing cluster state data.
Controller Manager: Manages various controllers that regulate the state of the cluster.
Scheduler: Assigns workloads to worker nodes.

Worker Node Components

Kubelet: An agent that runs on each worker node and ensures containers are running.
Kube-proxy: Maintains network rules and facilitates communication between services.
Container Runtime: Software responsible for running containers (e.g., Docker, containerd).

Kubernetes Objects

Kubernetes uses various objects to represent the state of your cluster:

Pod

A Pod is the smallest deployable unit in Kubernetes. It can contain one or more containers that share storage, network, and specifications on how to run.

Example Pod definition:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: nginx

Service

A Service is an abstraction that defines a logical set of Pods and a policy to access them. It allows you to expose your application to external traffic.

Example Service definition:

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: MyApp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 9376

Deployments and Scaling

Deployments provide declarative updates to your applications. You can define a Deployment to create new ReplicaSets or to remove existing ones.

Example Deployment definition:

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

To scale a Deployment, you can use the following command:

$ kubectl scale deployment my-deployment --replicas=5

ConfigMaps and Secrets

ConfigMaps and Secrets allow you to decouple configuration artifacts from image content to keep containerized applications portable.

ConfigMap

A ConfigMap is used to store non-confidential data in key-value pairs.

Example ConfigMap definition:

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
data:
  my-key: my-value

Secret

A Secret is similar to a ConfigMap but is intended to hold sensitive information, such as passwords, OAuth tokens, and ssh keys.

Example Secret definition:

apiVersion: v1
kind: Secret
metadata:
  name: my-secret
type: Opaque
data:
  username: YWRtaW4=
  password: MWYyZDFlMmU2N2Rm

Networking in Kubernetes

Kubernetes networking model aims to provide a consistent and portable way to handle network communication for containerized applications. It includes several components:

Cluster Networking

Every Pod in a Kubernetes cluster has a unique IP address. Pods can communicate with each other using these IP addresses, regardless of which node they are on.

Services

Services provide a single point of access to a set of Pods. Services can be exposed both inside and outside the cluster.

Ingress

Ingress is an API object that manages external access to services, typically HTTP. It provides load balancing, SSL termination, and name-based virtual hosting.

Conclusion

In this tutorial, we have covered the basics of Kubernetes, including its architecture, key components, and essential objects. By understanding these fundamental concepts, you are well on your way to mastering Kubernetes and leveraging its powerful capabilities to manage containerized applications at scale.

For further learning, you can refer to the official Kubernetes documentation.

Kubernetes Tutorial