Architecture du déploiement

Système d'exploitation : CentOS 7.6

Noyau : 3.10.0-1062.4.1.el7.x86_64

Kubernetes : v1.16.2

Docker CE : 19.03

Configuration matérielle recommandée : 2 cœurs, 4 Go de RAM

Le composant Keepalived assure une adresse IP virtuelle (VIP) haute disponibilité pour l'API Server.

HAProxy répartit la charge entre les instances de l'API Server.

Préparation des nœuds

1. Désactiver SELinux et le pare-feu

sed -ri 's#^SELINUX=.*#SELINUX=disabled#' /etc/selinux/config
setenforce 0
systemctl disable firewalld --now

2. Désactiver l'espace d'échange (swap)

swapoff -a
sed -ri 's/.*swap.*/#&/' /etc/fstab

3. Configurer la résolution de noms locale sur chaque machine

cat >> /etc/hosts <<EOF
192.168.1.10 m1
192.168.1.11 m2
192.168.1.12 m3
192.168.1.21 w1
192.168.1.22 w2
EOF

4. Établir l'accès SSH sans mot de passe depuis le nœud de contrôle principal

# Sur le nœud m1
ssh-keygen -t rsa -N ""
for host in m2 m3 w1 w2; do ssh-copy-id $host; done

5. Appliquer les paramètres du noyau nécessaires

cat <<EOF | tee /etc/sysctl.d/kubernetes.conf
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward = 1
vm.swappiness = 0
EOF
sysctl --system

6. Charger les modules IPVS pour kube-proxy

cat > /etc/modules-load.d/ipvs.conf <<EOF
ip_vs
ip_vs_rr
ip_vs_wrr
ip_vs_sh
nf_conntrack_ipv4
EOF
systemctl restart systemd-modules-load.service

7. Configurer les dépôts logiciels (yum)

cat > /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=0
EOF
wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

Déploiement de l'infrastructure de haute disponibilité

Installer Keepalived et HAProxy sur les nœuds prévus pour héberger le plan de contrôle (m1, m2).

yum install -y keepalived haproxy

Configuration de Keepalived (exemple pour le nœud m1, rôle MASTER) :

vrrp_script check_haproxy {
    script "/usr/bin/killall -0 haproxy"
    interval 2
    weight 20
}

vrrp_instance HA_K8S {
    state MASTER
    interface eth0
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass K8sHA!
    }
    virtual_ipaddress {
        192.168.1.100/24
    }
    track_script {
        check_haproxy
    }
}

Configuration identique pour le nœud m2, avec state BACKUP et priority 90.

Configuration de HAProxy sur m1 et m2 :

listen k8s-api
    bind 192.168.1.100:7443
    mode tcp
    balance roundrobin
    timeout server 15m
    timeout connect 15s
    server m1 192.168.1.10:6443 check inter 5s fall 3 rise 2
    server m2 192.168.1.11:6443 check inter 5s fall 3 rise 2
    server m3 192.168.1.12:6443 check inter 5s fall 3 rise 2

Activer et démarrer les servicse :

systemctl enable --now keepalived haproxy

Installation de Kubernetes

Installer les composants requis sur tous les nœuds.

yum install -y kubelet-1.16.2 kubeadm-1.16.2 kubectl-1.16.2 ipvsadm ipset docker-ce-19.03.13
systemctl enable --now docker kubelet

Créer le fichier de configuration d'initialisation (cluster-config.yaml) sur le premier nœud maître (m1).

cat > cluster-config.yaml <<EOF
apiVersion: kubeadm.k8s.io/v1beta2
kind: ClusterConfiguration
kubernetesVersion: v1.16.2
controlPlaneEndpoint: "192.168.1.100:7443"
networking:
  podSubnet: "10.244.0.0/16"
  serviceSubnet: "10.96.0.0/12"
imageRepository: registry.aliyuncs.com/google_containers
---
apiVersion: kubeadm.k8s.io/v1beta2
kind: InitConfiguration
localAPIEndpoint:
  advertiseAddress: "192.168.1.10"
  bindPort: 6443
EOF

Télécharger les images requises et initialiser le cluster sur m1.

kubeadm config images pull --config cluster-config.yaml
kubeadm init --config cluster-config.yaml --upload-certs

Configurer l'accès kubectl pour l'utilisateur courant :

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

Ajout des nœuds maîtres supplémentaires

Copier les certificats et le fichier admin.conf depuis m1 vers m2 et m3.

USER=root
MASTERS="m2 m3"
for h in $MASTERS; do
    ssh $USER@$h "mkdir -p /etc/kubernetes/pki/etcd"
    scp /etc/kubernetes/pki/ca.crt /etc/kubernetes/pki/ca.key $USER@$h:/etc/kubernetes/pki/
    scp /etc/kubernetes/pki/sa.key /etc/kubernetes/pki/sa.pub $USER@$h:/etc/kubernetes/pki/
    scp /etc/kubernetes/pki/front-proxy-ca.crt /etc/kubernetes/pki/front-proxy-ca.key $USER@$h:/etc/kubernetes/pki/
    scp /etc/kubernetes/pki/etcd/ca.crt /etc/kubernetes/pki/etcd/ca.key $USER@$h:/etc/kubernetes/pki/etcd/
    scp /etc/kubernetes/admin.conf $USER@$h:/etc/kubernetes/
done

Rejoindre le cluster en tant que nœud maître sur m2 et m3 (les commandes exactes sont fournies par la sortie de kubeadm init).

kubeadm join 192.168.1.100:7443 --token <TOKEN> --discovery-token-ca-cert-hash sha256:<HASH> --control-plane --certificate-key <CERT_KEY>

Ajout des nœuds de travail

Rejoindre le cluster sans l'option --control-plane sur w1 et w2.

kubeadm join 192.168.1.100:7443 --token <TOKEN> --discovery-token-ca-cert-hash sha256:<HASH>

Déploiement du réseau de pods

Installer le plugin réseau Flannel. L'état des nœuds passera à Ready une fois les pods du plugin en fonctionnement.

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Vérifier l'état final du cluster :

kubectl get nodes -o wide
kubectl get pods -A