Implementation of building Kubernetes cluster with VirtualBox+Ubuntu16

The beginning of Kubernetes operation and maintenance is of course inseparable from the construction of a cluster environment. This article records the entire process of building Kubernetes on a machine using VirtualBox + Ubuntu 16, including some problems encountered and their solutions.

About Kubernetes

Here is an explanation of Kubernetes from Wikipedia:

Kubernetes (often referred to as K8s) is an open source system for automatically deploying, scaling, and managing containerized applications. The system was designed by Google and donated to the Cloud Native Computing Foundation (now part of the Linux Foundation) for use.
It aims to provide "a platform for automating the deployment, scaling, and running of application containers across clusters of hosts." It supports a range of container tools, including Docker.

Kubernetes can provide us with service discovery and load balancing, storage orchestration, automatic deployment and rollback, automatic completion of box packing, self-healing, and key and configuration management capabilities.

Basic environment preparation

Install VirtualBox

VirtualBox is a powerful virtual machine software that is open source and free. Here is the download address. Installing VirtualBox is very simple, so I won’t go into details here.

Download Ubuntu 16 system image

Here I chose Ubuntu 16 as the system image. Of course, you can also use other systems, such as CentOS, etc. Download address of Ubuntu 16.

Virtual Machine x3

After installing VirtualBox and downloading the Ubuntu 16 image, we first need to build three Ubuntu 16 virtual machines. The process of creating a new virtual machine is relatively simple, just follow the steps one by one. After the new creation is completed, we need to configure each virtual machine accordingly. The user used during configuration should be the root user.

Virtual machine IP

Since we are using virtual machines, we will configure a network card for each virtual machine so that each virtual machine can access the Internet. There are two ways:

• Using a bridged network card, the IP of each virtual machine will be in the host network segment, supporting virtual machines to access the Internet
• Use NAT network + port forwarding, set the network segment by yourself, and support virtual machine Internet access

You can use any of these methods to configure a network card for the virtual machine so that the virtual machine can access the Internet.

It should be noted that after the cluster is built, the IP address of each node in the cluster must remain unchanged, otherwise the node needs to be rejoined.

The simple way is to put the virtual machine into sleep mode instead of shutting it down, and then wake it up next time.

In the cluster, we use the intranet address. You can find the intranet address corresponding to each virtual machine through ifconfig or ip addr:

> ifconfig

enp0s3 Link encap:Ethernet HWaddr 08:00:27:6f:23:2a  
          inet addr:10.0.2.4 Bcast:10.0.2.255 Mask:255.255.255.0
          inet6 addr: fe80::a00:27ff:fe6f:232a/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
          RX packets:3277016 errors:0 dropped:0 overruns:0 frame:0
          TX packets:3385793 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:1084480916 (1.0 GB) TX bytes:2079122979 (2.0 GB)

The address of this virtual machine (master) is 10.0.2.4.

Configuring the Hostname

The node name of Kubernetes is determined by the host name, so we can set the host names of the three virtual machines to master, node1, and node2 respectively. To change the host name, modify the /etc/hosts file and restart the virtual machine:

# /etc/hosts
10.0.2.4 master
10.0.2.5 node1
10.0.2.6 node2

SSH non-encrypted connection

After the virtual machines are running, the first thing we need to do is to connect the three virtual machines, that is, to configure SSH password-free connection.
First, generate SSH public and private keys on one of the virtual machines:

ssh-keygen -t rsa -C '[email protected]' -f ~/.ssh/id_rsa -q -N ''

Parameter description of ssh-keygen:

• -t rsa specifies the encryption algorithm as RSA
• -C '[email protected]' is used to provide a note indicating who generated the private key
• -f ~/.ssh/id_rsa specifies the location where the private key is generated
• -q -N '' means not to encrypt the private key and use silent mode

Distribute the public and private keys to the other two virtual machines, and write the contents of the public key (~/.ssh/id_rsa.pub) to the ~/.ssh/authorized_keys file on all three virtual machines, and set the permissions of the ~/.ssh/authorized_keys file to 400:

cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
chmod 400 ~/.ssh/authorized_keys

After the configuration is complete, we will be able to connect to another virtual machine on one of the virtual machines in the following ways:

# On the master node, ssh root@node1

Kubernetes cluster construction

After setting up the three virtual machines, we can start building a Kubernetes cluster with three nodes.

Install Docker

apt-get update -y
apt-get install -y \
  apt-transport-https \
  ca-certificates \
  curl \
  gnupg \
  lsb-release
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# INSTALL DOCKER ENGINE
apt-get update -y
apt-get install -y docker-ce docker-ce-cli containerd.io

# Configure Docker to start on boot
systemctl enable docker.service
systemctl enable containerd.service

# Start Docker
systemctl start docker

Install kubeadm, kubelet and kubectl

The image source used here is Alibaba Cloud:

# Update the apt package index and install the packages required to use the Kubernetes apt repository apt-get update -y
apt-get install -y apt-transport-https ca-certificates curl

# Download Google Cloud public signing key# curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
curl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add -

# Add Kubernetes apt repository# echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
echo "deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Update the apt package index, install kubelet, kubeadm and kubectl, and lock their versions apt-get update -y
apt-get install -y kubelet kubeadm kubectl
apt-mark hold kubelet kubeadm kubectl

Turn off SWAP

Edit the /etc/fstab file and comment out the swap partition configuration:

#/dev/mapper/master--vg-swap_1 none swap sw 0 0

Pre-download the image

Get the mirror list needed by kubeadm init:

> kubeadm config images list

k8s.gcr.io/kube-apiserver:v1.21.1
k8s.gcr.io/kube-controller-manager:v1.21.1
k8s.gcr.io/kube-scheduler:v1.21.1
k8s.gcr.io/kube-proxy:v1.21.1
k8s.gcr.io/pause:3.4.1
k8s.gcr.io/etcd:3.4.13-0
k8s.gcr.io/coredns/coredns:v1.8.0

The image source of k8s is out of reach for domestic users, but we can first pull it to the domestic image warehouse or the image warehouse that can be used, such as Alibaba Cloud's container image service ACR and Docker's official image warehouse DockerHub.

We can create a new GitHub code repository with only one Dockerfile, and its content is as follows:

FROM k8s.gcr.io/kube-apiserver:v1.21.0

Then create a new image in Alibaba Cloud's container image service ACR and associate it with the GitHub code repository. The built image is the k8s image we want, such as k8s.gcr.io/kube-apiserver:v1.21.1 above, but you need to re-label the image when using it.

After building all the required images in ACR, use the following script to quickly handle the task of tagging the images:

# Pull images from aliyun registry
kubeadm config images list | sed -e 's/^/docker pull /g' -e 's#k8s.gcr.io#registry.cn-shenzhen.aliyuncs.com/k8scat#g' -e 's#/coredns/coredns#/coredns#g' | sh -x

# Tag images
docker images | grep k8scat | awk '{print "docker tag",$1":"$2,$1":"$2}' | sed -e 's#registry.cn-shenzhen.aliyuncs.com/k8scat#k8s.gcr.io#2' | sh -x
docker tag k8s.gcr.io/coredns:v1.8.0 k8s.gcr.io/coredns/coredns:v1.8.0

# Remove images
docker images | grep k8scat | awk '{print "docker rmi",$1":"$2}' | sh -x

Initialize the master node

10.0.2.4 is the IP address of the master node. Set the pod network segment to 192.168.16.0/20:

> kubeadm init --apiserver-advertise-address=10.0.2.4 --pod-network-cidr=192.168.16.0/20

kubeadm join 10.0.2.4:6443 --token ioshf8.40n8i0rjsehpigcl \
    --discovery-token-ca-cert-hash sha256:085d36848b2ee8ae9032d27a444795bc0e459f54ba043500d19d2c6fb044b065

Add node

kubeadm join 10.0.2.4:6443 --token ioshf8.40n8i0rjsehpigcl \
    --discovery-token-ca-cert-hash sha256:085d36848b2ee8ae9032d27a444795bc0e459f54ba043500d19d2c6fb044b065

Distribute kubectl configuration files

scp master:/etc/kubernetes/admin.conf /etc/kubernetes/admin.conf
echo 'export KUBECONFIG="/etc/kubernetes/admin.conf"' >> /etc/profile
source /etc/profile

Installing the Network Plugin

Here we use Weave Net:

# curl -L "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')" > weave-net.yaml

# With IPALLOC_RANGE
kubectl apply -f https://gist.githubusercontent.com/k8scat/c6a1aa5a1bdcb8c220368dd2db69bedf/raw/da1410eea6771c56e93f191df82206be8e722112/k8s-weave-net.yaml

This is the end of this article about the implementation of building a Kubernetes cluster with VirtualBox+Ubuntu16. For more information about building a Kubernetes cluster with VirtualBox+Ubuntu16, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!