How to Install Kubernetes Cluster on Centos 7

Installing kubeadm

This page shows how to install the kubeadm toolbox. For information on how to create a cluster with kubeadm once you have performed this installation process, see the Using kubeadm to Create a Cluster page.

Before you begin

A compatible Linux host. The Kubernetes project provides generic instructions for Linux distributions based on Debian and Red Hat, and those distributions without a package manager.
2 GB or more of RAM per machine (any less will leave little room for your apps).
2 CPUs or more.
Full network connectivity between all machines in the cluster (public or private network is fine).
Unique hostname, MAC address, and product_uuid for every node. See here for more details.
Certain ports are open on your machines. See here for more details.
Swap disabled. You MUST disable swap in order for the kubelet to work properly.

Verify the MAC address and product_uuid are unique for every node

You can get the MAC address of the network interfaces using the command ip link or ifconfig -a
The product_uuid can be checked by using the command sudo cat /sys/class/dmi/id/product_uuid

It is very likely that hardware devices will have unique addresses, although some virtual machines may have identical values. Kubernetes uses these values to uniquely identify the nodes in the cluster. If these values are not unique to each node, the installation process may fail.

Check network adapters

If you have more than one network adapter, and your Kubernetes components are not reachable on the default route, we recommend you add IP route(s) so Kubernetes cluster addresses go via the appropriate adapter.

Letting iptables see bridged traffic

Make sure that the br_netfilter module is loaded. This can be done by running lsmod | grep br_netfilter. To load it explicitly call sudo modprobe br_netfilter.

As a requirement for your Linux Node's iptables to correctly see bridged traffic, you should ensure net.bridge.bridge-nf-call-iptables is set to 1 in your sysctl config, e.g.

            cat              <<EOF | sudo tee /etc/modules-load.d/k8s.conf                            br_netfilter                            EOF              cat              <<EOF | sudo tee /etc/sysctl.d/k8s.conf                            net.bridge.bridge-nf-call-ip6tables = 1                            net.bridge.bridge-nf-call-iptables = 1                            EOF              sudo sysctl --system

For more details please see the Network Plugin Requirements page.

Check required ports

These required ports need to be open in order for Kubernetes components to communicate with each other. You can use telnet to check if a port is open. For example:

The pod network plugin you use (see below) may also require certain ports to be open. Since this differs with each pod network plugin, please see the documentation for the plugins about what port(s) those need.

Installing runtime

To run containers in Pods, Kubernetes uses a container runtime.

Linux nodes
other operating systems

By default, Kubernetes uses the Container Runtime Interface (CRI) to interface with your chosen container runtime.

If you don't specify a runtime, kubeadm automatically tries to detect an installed container runtime by scanning through a list of well known Unix domain sockets. The following table lists container runtimes and their associated socket paths:

Container runtimes and their socket paths
Runtime	Path to Unix domain socket
Docker	`/var/run/dockershim.sock`
containerd	`/run/containerd/containerd.sock`
CRI-O	`/var/run/crio/crio.sock`

If both Docker and containerd are detected, Docker takes precedence. This is needed because Docker 18.09 ships with containerd and both are detectable even if you only installed Docker. If any other two or more runtimes are detected, kubeadm exits with an error.

The kubelet integrates with Docker through the built-in dockershim CRI implementation.

See container runtimes for more information.

By default, kubeadm uses Docker as the container runtime. The kubelet integrates with Docker through the built-in dockershim CRI implementation.

See container runtimes for more information.

Installing kubeadm, kubelet and kubectl

You will install these packages on all of your machines:

kubeadm: the command to bootstrap the cluster.
kubelet: the component that runs on all of the machines in your cluster and does things like starting pods and containers.
kubectl: the command line util to talk to your cluster.

kubeadm will not install or manage kubelet or kubectl for you, so you will need to ensure they match the version of the Kubernetes control plane you want kubeadm to install for you. If you do not, there is a risk of a version skew occurring that can lead to unexpected, buggy behaviour. However, one minor version skew between the kubelet and the control plane is supported, but the kubelet version may never exceed the API server version. For example, the kubelet running 1.7.0 should be fully compatible with a 1.8.0 API server, but not vice versa.

For information about installing kubectl, see Install and set up kubectl.

For more information on version skews, see:

Kubernetes version and version-skew policy
Kubeadm-specific version skew policy

Debian-based distributions
Red Hat-based distributions
Without a package manager

Update the apt package index and install packages needed to use the Kubernetes apt repository:

                    sudo apt-get update sudo apt-get install -y apt-transport-https ca-certificates curl

Download the Google Cloud public signing key:

                    sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg

Add the 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

Update apt package index, install kubelet, kubeadm and kubectl, and pin their version:

                    sudo apt-get update sudo apt-get install -y kubelet kubeadm kubectl sudo apt-mark hold kubelet kubeadm kubectl

                cat                  <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo                                    [kubernetes]                                    name=Kubernetes                                    baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch                                    enabled=1                                    gpgcheck=1                                    repo_gpgcheck=1                                    gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg                                    exclude=kubelet kubeadm kubectl                                    EOF                  # Set SELinux in permissive mode (effectively disabling it)                  sudo setenforce                  0                  sudo sed -i                  's/^SELINUX=enforcing$/SELINUX=permissive/'                  /etc/selinux/config  sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes  sudo systemctl                  enable                  --now kubelet

Notes:

Setting SELinux in permissive mode by running setenforce 0 and sed ... effectively disables it. This is required to allow containers to access the host filesystem, which is needed by pod networks for example. You have to do this until SELinux support is improved in the kubelet.
You can leave SELinux enabled if you know how to configure it but it may require settings that are not supported by kubeadm.

Install CNI plugins (required for most pod network):

                                  CNI_VERSION                  =                  "v0.8.2"                  ARCH                  =                  "amd64"                  sudo mkdir -p /opt/cni/bin curl -L                  "https://github.com/containernetworking/plugins/releases/download/                  ${                  CNI_VERSION                  }                  /cni-plugins-linux-                  ${                  ARCH                  }                  -                  ${                  CNI_VERSION                  }                  .tgz"                  | sudo tar -C /opt/cni/bin -xz

Define the directory to download command files

                                  DOWNLOAD_DIR                  =/usr/local/bin sudo mkdir -p                  $DOWNLOAD_DIR

Install crictl (required for kubeadm / Kubelet Container Runtime Interface (CRI))

                                  CRICTL_VERSION                  =                  "v1.22.0"                  ARCH                  =                  "amd64"                  curl -L                  "https://github.com/kubernetes-sigs/cri-tools/releases/download/                  ${                  CRICTL_VERSION                  }                  /crictl-                  ${                  CRICTL_VERSION                  }                  -linux-                  ${                  ARCH                  }                  .tar.gz"                  | sudo tar -C                  $DOWNLOAD_DIR                  -xz

Install kubeadm, kubelet, kubectl and add a kubelet systemd service:

                                  RELEASE                  =                  "                  $(curl -sSL https://dl.k8s.io/release/stable.txt)                  "                  ARCH                  =                  "amd64"                  cd                  $DOWNLOAD_DIR                  sudo curl -L --remote-name-all https://storage.googleapis.com/kubernetes-release/release/${                  RELEASE                  }/bin/linux/${                  ARCH                  }/{kubeadm,kubelet,kubectl}                  sudo chmod +x                  {kubeadm,kubelet,kubectl}                  RELEASE_VERSION                  =                  "v0.4.0"                  curl -sSL                  "https://raw.githubusercontent.com/kubernetes/release/                  ${                  RELEASE_VERSION                  }                  /cmd/kubepkg/templates/latest/deb/kubelet/lib/systemd/system/kubelet.service"                  | sed                  "s:/usr/bin:                  ${                  DOWNLOAD_DIR                  }                  :g"                  | sudo tee /etc/systemd/system/kubelet.service sudo mkdir -p /etc/systemd/system/kubelet.service.d curl -sSL                  "https://raw.githubusercontent.com/kubernetes/release/                  ${                  RELEASE_VERSION                  }                  /cmd/kubepkg/templates/latest/deb/kubeadm/10-kubeadm.conf"                  | sed                  "s:/usr/bin:                  ${                  DOWNLOAD_DIR                  }                  :g"                  | sudo tee /etc/systemd/system/kubelet.service.d/10-kubeadm.conf

Enable and start kubelet:

                systemctl                  enable                  --now kubelet

The kubelet is now restarting every few seconds, as it waits in a crashloop for kubeadm to tell it what to do.

Configuring a cgroup driver

Both the container runtime and the kubelet have a property called "cgroup driver", which is important for the management of cgroups on Linux machines.

Troubleshooting

If you are running into difficulties with kubeadm, please consult our troubleshooting docs.

What's next

Using kubeadm to Create a Cluster

How to Install Kubernetes Cluster on Centos 7

Source: https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/

Jull Heeut1938