Comment installer Kubernetes sur CentOS 7, Ubuntu 18.04 / 16.04 et Debian 9

Kubernetes est un outil open source d'orchestration de conteneurs de qualité production qui permet d'automatiser le déploiement, la mise à l'échelle et la gestion des applications conteneurisées. Google a initialement conçu Kubernetes et est maintenant géré par la Cloud Native Computing Foundation.

Vous pouvez appeler Kubernetes est un gestionnaire de cluster pour Docker , et il fournit presque les mêmes fonctionnalités que Docker Swarm . Avec Kubernetes, vous pouvez déployer n'importe quel nombre de réplicas de conteneurs sur un cluster de nœuds, et Kubernetes gérera les restes (où faire apparaître les conteneurs) pour vous.

Nous pouvons exécuter Kubernetes sur une machine locale en utilisant les méthodes ci-dessous,

1. MinKube – Un cluster Kubernetes à nœud unique pour le développement et les tests.
2. Kubeadm-dind (Kuberadm) – Un cluster Kubernetes multi-nœuds

Vous pouvez lire toutes les méthodes ici .

Ici, nous allons déployer un cluster Kubernetes multi-nœuds à l'aide de kubeadm. Dans cette configuration multi-nœuds, nous aurons un nœud maître et plusieurs nœuds de travail (sbires).

Composants

Nœud maître

serveur kube-API : Il s'agit d'un serveur d'API, qui s'exécute sur le nœud maître qui expose l'API Kubernetes
etcd : Un magasin de clés qui stocke les données du cluster Kubenetes
kube-scheduler : Il s'agit d'un planificateur qui s'exécute sur le nœud maître qui surveille les pods nouvellement créés et exécute ces pods sur certains nœuds en fonction de la disponibilité des ressources.
kube-controller-manager : Il s'agit d'un gestionnaire de contrôle qui s'exécute sur le gestionnaire responsable de la surveillance des nœuds et de la maintenance de la réplication des pods.
cloud-controller-manager : Un gestionnaire de contrôle du cloud qui interagit avec les fournisseurs de cloud sous-jacents (Ex :DigitalOcean, Rancher, etc.).

Nœuds de travail

kubelet : Il s'exécute sur tous les nœuds de travail et gère des tâches telles que le démarrage de pods et de conteneurs.
kube-proxy : Il s'agit d'un proxy réseau Kubernetes qui transfère les requêtes entrantes TCP/UDP au conteneur principal.
Container Runtime : C'est un logiciel conteneur (Docker)

Environnement

Nœud	Nom d'hôte	Adresse IP	SE	CPU	RAM
Nœud maître	master.itzgeek.local	192.168.1.10	CentOS 7 / RHEL 7	2	2 Go
Nœud Minion 1	node1.itzgeek.local	192.168.1.20	Ubuntu 18.04 / 16.04	2	2 Go
Nœud Minion 2	node2.itzgeek.local	192.168.1.30	Debian 9	2	2 Go

Vous devez désactiver le swap pour que Kubernetes fonctionne correctement

Ici, j'utilise un environnement mixte pour cette démo. Mais, je vous demande d'utiliser le système d'exploitation similaire uniquement pour faciliter le dépannage.

Prérequis

Devenez l'utilisateur root.

su -

OU

sudo su -

Définir le nom d'hôte

Définissez un nom d'hôte unique pour tous vos nœuds. Exemple :

hostnamectl set-hostname master.itzgeek.local

Faire une entrée d'hôte ou DNS record pour résoudre le nom d'hôte de tous les nœuds.

vi /etc/hosts

Entrée :

192.168.1.10 master.itzgeek.local master
192.168.1.20 node1.itzgeek.local node1
192.168.1.30 node2.itzgeek.local node2

Pare-feu

Configurez le pare-feu pour que Kubernetes fonctionne correctement.

Sur le nœud maître

FirwallD :

firewall-cmd --permanent --add-port=6443/tcp
firewall-cmd --permanent --add-port=2379-2380/tcp
firewall-cmd --permanent --add-port=10250/tcp
firewall-cmd --permanent --add-port=10251/tcp
firewall-cmd --permanent --add-port=10252/tcp
firewall-cmd --permanent --add-port=10255/tcp
firewall-cmd --reload

UFW :

ufw allow 6443/tcp
ufw allow 2379tcp
ufw allow 2380/tcp
ufw allow 10250/tcp
ufw allow 10251/tcp
ufw allow 10252/tcp
ufw allow 10255/tcp
ufw reload

Sur les nœuds de travail

FirwallD :

firewall-cmd --permanent --add-port=10251/tcp
firewall-cmd --permanent --add-port=10255/tcp
firewall-cmd --reload

UFW :

ufw allow 10251/tcp
ufw allow 10255/tcp
ufw reload

SELinux

Pensez à désactiver SELinux sur CentOS 7 / RHEL 7 nœuds.

setenforce 0

sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config

Paramètres du noyau

Dans RHEL 7/CentOS 7 , définissez net.bridge.bridge-nf-call-iptables sur 1 dans votre configuration sysctl.

cat <<EOF > /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
sysctl -p

Installer Docker

Installez Docker sur tous vos nœuds (Maître et Minions). La version 18.06 de Docker est recommandée, mais les versions 1.11, 1.12, 1.13 et 17.03 fonctionnent également bien avec Kubernetes.

CentOS 7 / RHEL 7

### Install Docker from CentOS/RHEL repository ###

yum install -y docker
systemctl enable docker 
systemctl start docker

OR

### Install Docker CE 18.06 from Docker's CentOS repositories ###

# Install Prerequisites 
yum install -y yum-utils device-mapper-persistent-data lvm2

# Add Docker repository 
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

# Install Docker
yum update
yum install -y docker-ce-18.06.1.ce

# Create Docker Directory 
mkdir /etc/docker

# Setup Docker Daemon
cat > /etc/docker/daemon.json <<EOF
{
"exec-opts": ["native.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts": {
"max-size": "100m"
},
"storage-driver": "overlay2",
"storage-opts": [
"overlay2.override_kernel_check=true"
]
}
EOF

mkdir -p /etc/systemd/system/docker.service.d

# Restart Docker Daemon
systemctl daemon-reload
systemctl restart docker
systemctl enable docker

Ubuntu 18.04 / Ubuntu 16.04

### Install Docker from Ubuntu's repositories ###

apt-get update
apt-get install -y docker.io

OR

### Install Docker CE 18.06 from Docker's repositories for Ubuntu  ###

# Install Prerequisites
apt-get update
apt-get install -y apt-transport-https ca-certificates curl software-properties-common

# Download GPG Key
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -

# Add Docker's Repository 
add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

# Install Docker
apt-get update
apt-get install -y docker-ce=18.06.0~ce~3-0~ubuntu

# Setup Daemon
cat > /etc/docker/daemon.json <<EOF
{
"exec-opts": ["native.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts": {
"max-size": "100m"
},
"storage-driver": "overlay2"
}
EOF

mkdir -p /etc/systemd/system/docker.service.d

# Restart Docker Daemon
systemctl daemon-reload
systemctl restart docker

Debian 9

### Install Docker from Debian's repositories ###

apt-get update
apt-get install -y docker.io

OR

### Install Docker CE 18.06 from Docker's repositories for Debian ###

# Install Prerequisites
apt-get update
apt-get install -y apt-transport-https ca-certificates curl software-properties-common

# Download GPG Key 
curl -fsSL https://download.docker.com/linux/debian/gpg | apt-key add -

# Add Docker's Repository
add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"

# Install Docker
apt-get update
apt-get install -y docker-ce=18.06.0~ce~3-0~debian

# Setup Daemon
cat > /etc/docker/daemon.json <<EOF
{
"exec-opts": ["native.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts": {
"max-size": "100m"
},
"storage-driver": "overlay2"
}
EOF

mkdir -p /etc/systemd/system/docker.service.d

# Restart Docker Daemon
systemctl daemon-reload
systemctl restart docker

Configurer le référentiel Kubernetes

Kubernetes les packages ne sont pas disponibles dans les référentiels du système d'exploitation, vous devez donc suivre les étapes ci-dessous pour configurer son référentiel sur tous vos nœuds.

### CentOS 7 / RHEL 7 ###

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
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=kube*
EOF

### Ubuntu 18.04 / 16.05 & Debian 9 ###

apt-get update
apt-get install -y curl apt-transport-https
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Installer kubeadm, kubelet et kubectl

Sur tous vos nœuds, exécutez les commandes suivantes pour installer les packages requis.

kubeadm :la commande pour créer le cluster.

kubelet :s'exécute sur toutes les machines de votre cluster et fait des choses comme démarrer des pods et des conteneurs.

kubectl :l'utilitaire de ligne de commande pour gérer votre cluster.

### CentOS 7 / RHEL 7 ###

yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
systemctl enable kubelet 
systemctl start kubelet
### Ubuntu 16.04 / Debian 9 ###

apt-get update
apt-get install -y kubelet kubeadm kubectl

Initialiser le maître Kubernetes

Sur le nœud maître, exécutez la commande kubeadm init dans le terminal pour initialiser le cluster.

En fonction du module complémentaire réseau que vous utilisez, vous devrez peut-être définir le --pod-network-cidr à une valeur précise. Ici, j'utilise le réseau Wave pod qui ne nécessite aucun argument supplémentaire.

kubeadm init

Sortie :

[init] Using Kubernetes version: v1.13.0
[preflight] Running pre-flight checks
        [WARNING Firewalld]: firewalld is active, please ensure ports [6443 10250] are open or your cluster may not function correctly
[preflight] Pulling images required for setting up a Kubernetes cluster
[preflight] This might take a minute or two, depending on the speed of your internet connection
[preflight] You can also perform this action in beforehand using 'kubeadm config images pull'

[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Activating the kubelet service
[certs] Using certificateDir folder "/etc/kubernetes/pki"
[certs] Generating "ca" certificate and key
[certs] Generating "apiserver-kubelet-client" certificate and key

.      .      .
.      .      .
.      .      .

[bootstraptoken] configured RBAC rules to allow certificate rotation for all node client certificates in the cluster
[bootstraptoken] creating the "cluster-info" ConfigMap in the "kube-public" namespace
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes master has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of machines by running the following on each node
as root:

  kubeadm join 192.168.1.10:6443 --token d1dyaj.31zxywbg93s1ywjy --discovery-token-ca-cert-hash sha256:71a91721595fde66b6382908d801266602a14de8e16bdb7a3cede21509427009

Gérer le cluster

Exécutez ces commandes dans le terminal pour gérer et travailler sur le cluster en tant qu'utilisateur normal.

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Exécutez la commande kubectl get pods –all-namespaces pour vérifier l'état du cluster.

kubectl get pods --all-namespaces

Sortie :

Vous pouvez voir que coredns pod est en attente et l'état devrait changer une fois que vous aurez installé le réseau de pods.

Configurer le réseau des pods

Nous devons configurer un module complémentaire de réseau de pods sur le cluster afin que les pods puissent communiquer entre eux. Il existe plusieurs projets fournissent des réseaux de pods Kubernetes à savoir calicot, canal, flanelle, etc.

Ici, nous utiliserons le réseau Wave Pod pour cette démo.

export kubever=$(kubectl version | base64 | tr -d '\n')
kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$kubever"

Sortie :

serviceaccount/weave-net created
clusterrole.rbac.authorization.k8s.io/weave-net created
clusterrolebinding.rbac.authorization.k8s.io/weave-net created
role.rbac.authorization.k8s.io/weave-net created
rolebinding.rbac.authorization.k8s.io/weave-net created
daemonset.extensions/weave-net created

Vérifiez à nouveau l'état du cluster. Le pod coredns devrait maintenant être en cours d'exécution.

kubectl get pods --all-namespaces

Sortie :

Joindre les noeuds worker au cluster Kuberenete

Si vous vous en souvenez, il y avait un jeton dans la sortie de la commande kubeadm init pour joindre les nœuds. Utilisez le jeton et rejoignez tous vos nœuds de travail.

kubeadm join 192.168.1.10:6443 --token d1dyaj.31zxywbg93s1ywjy --discovery-token-ca-cert-hash sha256:71a91721595fde66b6382908d801266602a14de8e16bdb7a3cede21509427009

Sortie :

[preflight] Running pre-flight checks
[discovery] Trying to connect to API Server "192.168.1.10:6443"
[discovery] Created cluster-info discovery client, requesting info from "https://192.168.1.10:6443"
[discovery] Requesting info from "https://192.168.1.10:6443" again to validate TLS against the pinned public key
[discovery] Cluster info signature and contents are valid and TLS certificate validates against pinned roots, will use API Server "192.168.1.10:6443"
[discovery] Successfully established connection with API Server "192.168.1.10:6443"
[join] Reading configuration from the cluster...
[join] FYI: You can look at this config file with 'kubectl -n kube-system get cm kubeadm-config -oyaml'
[kubelet] Downloading configuration for the kubelet from the "kubelet-config-1.13" ConfigMap in the kube-system namespace
[kubelet-start] Writing kubelet configuration to file "/var/lib/kubelet/config.yaml"
[kubelet-start] Writing kubelet environment file with flags to file "/var/lib/kubelet/kubeadm-flags.env"
[kubelet-start] Activating the kubelet service
[tlsbootstrap] Waiting for the kubelet to perform the TLS Bootstrap...
[patchnode] Uploading the CRI Socket information "/var/run/dockershim.sock" to the Node API object "node1.itzgeek.local" as an annotation

This node has joined the cluster:
* Certificate signing request was sent to apiserver and a response was received.
* The Kubelet was informed of the new secure connection details.

Run 'kubectl get nodes' on the master to see this node join the cluster.

La sortie ci-dessus confirme que le nœud a été ajouté avec succès au cluster.

Maintenant, vérifiez l'état des nœuds de travail sur le nœud maître à l'aide de la commande suivante.

kubectl get nodes

Sortie :

Vous devriez voir que les nœuds de travail sont à l'état prêt.

Dans notre prochain article, nous déploierons des pods, des services et des contrôleurs de réplication dans Kubernetes.

C'est tout.