Containers and Pods
In this tutorial, we are going to discuss about basic concepts of Kubernetes. Let’s start from containers and pods. Pods are the smallest and most basic building block of the Kubernetes model. A pod consists of one or more containers, storage resources, and a unique IP address in the Kubernetes cluster network. In order to run containers, Kubernetes shedules pods to run on servers in the cluster. When a pod is sheduled, the server will run the containers that are part of that pods.
In order to run and manage containers with Kubernetes, you will need to use pods. In this lesson, we discuss the basics of what pods are and how they are related to containers within the world of Kubernetes. We will create a simple pod and then we will look at some ways to explore and interact with pods in your Kubernetes cluster.
Here are the commands used in this tutorial:
Create a simple pod running an nginx container:
cat << EOF | kubectl create -f -
apiVersion: v1
kind: Pod
metadata:
name: nginx
spec:
containers:
- name: nginx
image: nginx
EOF
Get a list of pods and verify that your new nginx pod is in the Running state:
kubectl get pods
Get more information about your nginx pod:
kubectl describe pod nginx
Delete the pod:
kubectl delete pod nginx
Clustering and Nodes
Kubernetes implements a clustered architecture. In a typical production environtment, you will have multiple servers that are able to run your workloads (containers). These are which actually run the containers are called nodes. A Kubernetes cluster has one or more control servers which manage and control the cluster and host the Kubernetes API. These control servers are usually separate from worker nodes, which run applications within the cluster.
Nodes are an essential part of the Kubernetes cluster. They are the machines where your cluster’s container workloads are executed. In this lesson, we will discuss what nodes are in Kubernetes, and we will explore some ways in which you can find information about nodes in your cluster.
Here are the commands used in this tutorial:
Get a list of nodes:
kubectl get nodes
Get more information about a specific node:
kubectl describe node $node_name
Networking in Kubernetes
When using Kubernetes, it is importanat to understand how Kubernetes implements networking between pods (and services) in the cluster. The Kubernetes networking model involves creating a virtual network across the whole cluster. This means that every pod on the cluster has a unique IP address, and can communicate with any other pods in the cluster, even if that other pod is running on a different node. Kubernetes supports a variety of networking plugins that implement this model in various ways. We are using Flannel in this practical tutorial.
Networking is an important part of understanding the basics of Kubernetes. This lesson provides a high-level overview of what a Kubernetes virtual cluster network looks like. We will also demonstrate how the network functions by contacting one pod from another pod over the virtual network.
Create a deployment with two nginx pods:
cat << EOF | kubectl create -f -
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx
labels:
app: nginx
spec:
replicas: 2
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.15.4
ports:
- containerPort: 80
EOF
Create a busybox pod to use for testing:
cat << EOF | kubectl create -f -
apiVersion: v1
kind: Pod
metadata:
name: busybox
spec:
containers:
- name: busybox
image: radial/busyboxplus:curl
args:
- sleep
- "1000"
EOF
Get the IP addresses of your pods:
kubectl get pods -o wide
Get the IP address of one of the nginx pods, then contact that nginx pod from the busybox pod using the nginx pod’s IP address:
kubectl exec busybox -- curl $nginx_pod_ip
Kubernetes Architecture and Components
Kubernetes includes multiple components that work together to provide the functionality of a Kubernetes cluster. The control plane components manage and control the cluster:
etcd: Provides distributed, synchronized data storage for the cluster state.
kube-apiserver: Serves the Kubernetes API, the primary interface for the cluster.
kube-controller-manager: Bundles several components into one package.
kube-scheduler: Schedules pods to run on individual nodes.
In addition to the control plane, each node also has:
kubelet: Agent that executes containers on each node.
kube-proxy: Handles network communication between nodes by adding firewall routing rules.
With kubeadm, many of these components are run as pods within the cluster itself.
A Kubernetes cluster is made up of multiple individual components running on the various machines that are part of the cluster. In this lesson, we will briefly discuss the major Kubernetes software components and what each of them do. We will also look into how these components are actually running in our cluster currently.
Here are the commands used in this lesson:
Get a list of system pods running in the cluster:
kubectl get pods -n kube-system
Check the status of the kubelet service:
sudo systemctl status kubelet
Conclusion
That’s all you need to know about basic concepts of Kubernetes on Linux server. There are more tutorials that will go into deeper explanation of using Kubernetes thoroughly, but this is a simple article to just get familiar with Kubernetes concepts on linux based server.
