Kubernetes (K8s): Orchestration & Resource Management

Topic Subtitle

• Kubernetes groups containers that constitute an application together into logical units for easy management and discovery
• The focus is not on single containers, but objects with different granularities within them
• Kubernetes includes objects and API extensions where you can customize to manage new things

What is Orchestration?

• Orchestration refers to the automated coordination
• It is the management, and organization of tasks and services across multiple distributed computing nodes
• It ensures these components work together to achieve a desired functionality or workflow

What is Resource Management?

• It refers to the coordinated and efficient allocation, scheduling, and control of resources
• Resources include CPU time, memory, storage, and network bandwidth across multiple computational nodes.

What is Kubernetes (K8s)?

• (K8s) is an open-source system for automating deployment, scaling, and management of containerized applications
• Containerized applications run across multiple machines referred to as nodes
• K8s builds upon 15+ years of experience running production workloads with ideas and best practices from the community
• K8s uses docker for clusters of machines and abstracts away the underlying infrastructure, OS for clusters
• K8s has a cloud-native ecosystem that is managed by the Cloud Native Computing Foundation

Important Note

• In this presentation, workload and application are are synonymous

K8s vs Docker Swarm Mode (DSM)

• K8s is more complex than Docker Swarm to setup
• K8s is a CNCF project with a broader community, and it is production-ready
• K8s has a steeper learning curve
• K8s is able to work with multiple container runtimes

Kubernetes Features that DSM Does Not

• Scheduler
• Stateful sets
• etc

Docker Swarm Features

• DSM has limited fault tolerance
• DSM integrates smoothly with the Docker CLI and Docker Compose

Kubernetes Scaling

• K8s provides autoscaling at the container and even the node level, while DSM scaling is only manual

Kubernetes API

• K8s has general and extensible API

Two Types of State

• K8s has a declarative service model lets you define the desired state of the various services in your application stack
• K8s monitors the cluster state and reconciles differences between the actual state and your expressed desired state

Kubernetes Technical Functionalities

• Manage different types of workloads for flexibility
• Includes multi-host Networking, Service Discovery, and Load Balancing
• Includes automatic Workload Placement for efficiency
• Implements auto-remediation for fault tolerance, resilience and reliability
• Horizontal and Vertical Scaling for elasticity
• Improved security
• A/B and Canary Deployments for testing

Kubernetes Architecture

• Implements manager-worker architecture
• The Control Plane (manager) is responsible for managing the state of the Kubernetes cluster, scheduling workloads, and handling the overall orchestration
• Worker Nodes (workers) run the actual workloads in the form of containers.
• A Kubernetes cluster is a collection of machines, called nodes, running containers
• The Control Plane Node(s) manage the Worker Nodes and everything that happens within the cluster
• Multiple Control Plane Nodes are used to ensure high-availability and failover capability of the cluster

Kube API Server

• Exposes the Kubernetes API and is the front end for the Kubernetes control plan
• Horizontally scalable

Etcd

• Consistent an highly available key value store that holds object definitions
• Backing store for all cluster data

Kube Scheduler

• It watches for newly created containers with no assigned node to select a node for them to run on, by considering
• Individual and collective resource requirements Hardware and software policy constraints Affinity and anti-affinity specifications

Controller Manager

• Runs controller processes
• Each controller is its own process
• Controller's include: node controller, replication controller and service account/token controllers

Cloud Controller

• Embeds cloud-specific control logic
• Links the cluster into the cloud provider's API, and separates out the components that interact with that cloud platform

Kubelet

• Node component that has the local, control plane agent that executes and monitors containers
• Responsible for workload management

Kube Proxy:

• Node component for Network proxy that implements part of the Service concept
• Creates and maintains network rules on nodes

High Level Kubernetes Tasks

• It makes global decisions about the cluster as well as detecting and responding to cluster and application events
• Control Plane components make the cluster’s current state match the desired state by reacting to events
• Automatically starting or restarting containers or pods
• Scaling the number of replicas of a given application or nodes

Terminology

• Desired state == what you want to run, what container images they use, the number of replicas, what network and disk resources you want to make available, and more
• Users describe the cluster’s desired state via textual descriptions or declarative model Controllers - will automatically manage your cluster to match the desired state

Kubernetes Objects - Abstractions

• Kubernetes objects represent the state of the system and is usually an application's component
• They have volume, a name-space and a node as part of the base objects
• Common elements support any type of workload through higher level abstractions that include: deployment,stateful set, daemon set, replica set and jobs

Key Aspect of Kubernetes Objects

• Kubernetes objects are a record of intent
• Once created, the Kubernetes system will constantly work to ensure that object exists
• By creating an object, tell k8s that you want your cluster's workload to look like and that is your cluster's desired state

Pod

• Basic execution unit of any Kubernetes application, and the smallest and simplest unit in the Kubernetes object model that you create or deploy
• Represents processes/components running on the cluster
• Composed by either a single container or a small number of containers that are tightly coupled and that share resources
• A Pod encapsulates an application’s container (or multiple ones), storage resources, a unique network IP, and options that govern how the container(s) should run

Kubernetes Declarative Model

• The declarative model is a way to describe an object
• It is where you define what the system should look like
• K8s ensures that the cluster matches this state regardless of the current state

Kubernetes Key Tool: Kubectl

• supports 3 kinds of managed objects
  • imperative commands, declarative object configuration and YML, JSON manifest files
• Includes a Kind for Pod, Deployment, Replication Controller, Job, Service
• Includes labels for key values tagged to deployable objects
• Selectable through actions and other declarations
• Specification declares pod configuration that might include fields managed by k8s

Idempotency

• Re-applying the same configuration file does not cause unnecessary changes if the cluster already matches the desired state

Version Control Friendly

• Declarative configurations are written in files, which can be version-controlled, enabling consistent management and tracking of changes, making it automation ready

Minikube Functionalities

• Implements with a local Kubernetes cluster on macOS, Linux, and Windows
• Best tool for local K8S application development and that supports all features that fit
• Runs with support for standard features

Kubernetes Preliminary Steps

• Start minikube with minikube start
• Get list of nodes with kubectl get nodes
• Get the list of available addons with minikube addons list
• Enable Kubernetes Dashboard with minikube addons enable dashboard
• Open the dashboard with minikube dashboard --url
• then, navigate to the dashboard url and check the available namespace with kubectl get namespaces

Kubernetes Addons

• The Addons use Kubernetes resources to implement cluster features
• Resources for addons belong within the kube-system namespace, such as:
• DNS to launch a DNS Pod and Service to resolve DNS names
• A web UI dashboard that allows users to manage and troubleshoot applications and the cluster itself
• Cluster level logging that is responsible saves container logs to a central log store

Kubernetes NameSpaces

• They use Kubernetes resources to implement cluster features, and belong located in the kube-system namespace. Some include:
  • DNS: Which Kubernetes uses to to launch a DNS Pod and Service on the cluster, and configures the kubelets to tell individual containers to use the DNS Service's IP to resolve DNS names
  • A Web UI Dashboard, that allow users to manage and troubleshoot applications running in the cluster, as well as the cluster itself
  • And Cluster-level Logging, that is responsible for saving container logs to a central log store with search/browsing interface
• The namespaces provide a scope for applications where Names of resources need to be unique within a namespace, but not across namespaces.

Common NameSpaces:

• the default Namespace
• Any default is for any object without a namespace
• Then, Kube-system acts as the home for objects and resources created by Kubernetes itself
• All objects can be handled through the kube node-lease, which is a special namespace that is readable by all users and is reserved for cluster bootstrapping and configuration.

Exercise 1: Create First Pod

• Start the process by running kubectl run my-pod --image=miciav/hello-go:1.0.0
• Make sure the program worked properly by listing it with, kubectl get pods
• You can also open up an instance the shell from inside the pod, by calling it with kubectl exec -it my-pod -- sh
• Now expose the pod port to the host system with, kubectl port-forward my-pod 8080:8180 and visit in a web browser 127.0.0.1 port, NOTE This is only for debugging and developing purposes To remove, call it with the command: kubectl delete pod my-pod

Declarative Model With Kubernetes

• Start with entering a directory
• Run it: kubectl apply -f 00_es01_nginx_pod.yml
• Use the same command as above to visualize what is going on through: watch kubectl get pods nginx and then kubectl describe pods nginx
• To view the contents open a file or use kubectl exec nginx to print out the environment variables
• Call port forward to have it working in our local system

Update Pod and Create Configuration by using

• kubectl create configmap nginx-data --from-file index.html
• Make sure it works properly by calling it by describing it describe configmaps nginx-data
• Delete a configuration you don't need by, calling with kubectl delete configmaps nginx-data

Kubernetes is an open-source system that automates the deployment, scaling, and management of containerized applications. It groups containers into logical units for easy management and discovery, focusing on objects with different granularities. Kubernetes also includes objects and API extensions for customized management.