Kubernetes logo

Cette doc détaille le déploiement d'un cluster de master

Pré-requis à l'installation

Installer docker (voir CD/DockerSwarm)

Disposer d'au moins 3 machines (physiques ou virtuelles) :

  • 3 machines seront appelées manager: manager1, manager2, manager3

Chaque machine devra avoir au minimum 4Go de RAM.

Disposer des adresses IP de chacune des machines.

Installation de Kubernetes

Sur chacune des machines où installer Kubernetes

1 - Ajouter une liste de dépôts au fichier kubernetes.repo :

sudo echo -e "[kubernetes]\nname=Kubernetes\nbaseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64\nenabled=1\ngpgcheck=1\nrepo_gpgcheck=1\ngpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg\n       https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg">/etc/yum.repos.d/kubernetes.repo

2 - Installer les paquets nécessaires à Kubernetes :

sudo yum install -y yum-versionlock keepalived haproxy ipvsadm kubelet kubectl kubeadm

sudo yum install -y https://packagecloud.io/linuxhq/hatop/packages/el/7/hatop-0.7.7-1.el7.centos.noarch.rpm/download.rpm

3 - Verrouiller la version de Kubernetes et de ses dépendances : 

sudo yum versionlock kubectl kubeadm kubelet

4 - Modifier le fichier sysctl.conf : 

sudo echo -e 'net.bridge.bridge-nf-call-iptables = 1\nvm.nr_hugepages = 0'>>/etc/sysctl.conf

5 - Appliquer la nouvelle configuration de sysctl : 

sudo sysctl --system

6 - Désactiver la mémoire swap : 

sudo swapoff -a;sed -i '/swap/d' /etc/fstab

7 - Désactiver le pare-feu : 

sudo systemctl disable firewalld
sudo systemctl stop firewalld

8 - Activer et démarrer Docker et Kubelet : 

sudo systemctl enable docker kubelet
sudo systemctl start docker kubelet

9 - Récupérer les images de configuration : 

sudo kubeadm config images pull

10 - Nettoyer le système d'une éventuelle précédente configuration de Kubernetes :

sudo kubeadm reset -f

11 - Désactiver SELinux :

sudo setenforce 0
sudo vim /etc/selinux/config

changer la valeur de SELINUX de enforcing à disabled pour desactiver SELinux de facon permanente

12 - Éditer le fichier /etc/hosts sur chaque noeud du cluster et ajouter dans ce fichier les ip des deux autres noeuds.

13 - Se connecter en SSH à chacun des comptes root de toutes les autres machines : 

ssh <root@machineIP>
ssh-copy-id <root@machineIP>

Installation de Keep Alived

Sur le manager1

1 - Éditer le fichier de configuration de Keep Alived :

cat >/etc/keepalived/keepalived.conf <<ENDF
global_defs {
    notification_email {
        root@kube.prj.ajc.com
    }
    notification_email_from kube01@kube.prj.ajc.com
    smtp_server localhost
    smtp_connect_timeout 30
    enable_script_security
}

vrrp_script check_haproxy {
        script "/usr/bin/killall -0 haproxy"
        interval 1
}

vrrp_instance VRRP1 {
    state MASTER
    interface eth0
    virtual_router_id 41
    priority 130
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 01b6d874f190
    }
    virtual_ipaddress {
        <ipmanager1>/24
    }
    track_script {
        check_haproxy
    }
}
ENDF

2 - Autoriser et activer Keep Alived : 

sudo systemctl enable keepalived
sudo systemctl start keepalived

Sur le manager2

1 - Éditer le fichier de configuration de Keep Alived :

cat >/etc/keepalived/keepalived.conf <<ENDF
global_defs {
    notification_email {
        root@kube.prj.ajc.com
    }
    notification_email_from kube01@kube.prj.ajc.com
    smtp_server localhost
    smtp_connect_timeout 30
    enable_script_security
}

vrrp_script check_haproxy {
        script "/usr/bin/killall -0 haproxy"
        interval 1
}

vrrp_instance VRRP1 {
    state SLAVE
    interface eth0
    virtual_router_id 41
    priority 130
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 01b6d874f190
    }
    virtual_ipaddress {
        <ipmanager2>/24
    }
    track_script {
        check_haproxy
    }
}
ENDF

2 - Autoriser et activer Keep Alived : 

sudo systemctl enable keepalived
sudo systemctl start keepalived

Sur le manager3

1 - Éditer le fichier de configuration de Keep Alived :

cat >/etc/keepalived/keepalived.conf <<ENDF
global_defs {
    notification_email {
        root@kube.prj.ajc.com
    }
    notification_email_from kube01@kube.prj.ajc.com
    smtp_server localhost
    smtp_connect_timeout 30
    enable_script_security
}

vrrp_script check_haproxy {
        script "/usr/bin/killall -0 haproxy"
        interval 1
}

vrrp_instance VRRP1 {
    state SLAVE
    interface eth0
    virtual_router_id 41
    priority 130
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 01b6d874f190
    }
    virtual_ipaddress {
        <ipmanager3>/24
    }
    track_script {
        check_haproxy
    }
}
ENDF

2 - Autoriser et activer Keep Alived : 

systemctl enable keepalived
systemctl start keepalived

Installation de HAProxy

Sur chacun des 3 managers

1 - Sauvegarder le fichier original de configuration de HA Proxy : 

mv /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.orig

2 - Copier les 60 premières lignes de ce fichier de configuration dans le nouveau : 

head -60 /etc/haproxy/haproxy.cfg.orig>/etc/haproxy/haproxy.cfg

3 - Éditer le nouveau fichier de configuration de HA Proxy (on changera manager 1, 2, 3 par les noms respectifs donnés aux vm si leurs noms sont différents de manager1, 2, 3:

cat >>/etc/haproxy/haproxy.cfg <<ENDF
frontend api-front
    bind 0.0.0.0:5443
    mode tcp
    option tcplog
    use_backend api-backend
backend api-backend
    mode tcp
    option tcplog
    option tcp-check
    balance roundrobin
    server manager1 <ipmanager1>:6443 check
    server manager2 <ipmanager2>:6443 check
    server manager3 <ipmanager3>:6443 check
ENDF

4 - Autoriser et démarrer HA Proxy :

sudo systemctl start haproxy
sudo systemctl enable haproxy

5 - Contrôler la présence de tous les noeuds : 

hatop -s /var/lib/haproxy/stats

Configuration sur le 1er manager

1 - Éditer le fichier de configuration initiale : 

cat >>/tmp/config.init.yml <<ENDF
apiVersion: kubeadm.k8s.io/v1beta1
kind: ClusterConfiguration
kubernetesVersion: stable
apiServer:
    certSANs:
        - "<ipmanager1>"
controlPlaneEndpoint: "<ipmanager1>:5443"
networking:
    podSubnet: "10.244.0.0/16"
ENDF

2 - Initialiser Kubernetes : 

kubeadm init --config=/tmp/config.init.yml --ignore-preflight-errors=NumCPU 2>&1|tee $HOME/kubeadm.init.log

(Conservez le retour de cette commande, cela nous servira pour une prochaine étape)

3 - Créer un répertoire de configuration de Kubernetes : 

mkdir -p $HOME/.kube
# Confirmer l'écrasement du fichier
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

4 - Installer Flannel :

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

5 - Attendre la fin de l'installation : 

watch kubectl get pods --all-namespaces -o wide

6 - Possible bug, le pod coredns reste en pending state éternellement, pour résoudre cela, il suffit d'éditer le fichier /etc/cni/net.d/10-flannel.conflist et de rajouter en première ligne (juste après la première accolade)

"cniVersion": "0.2.0",

Exemple d'un /etc/cni/net.d/10-flannel.conflist valide:

{
  "cniVersion": "0.2.0",
  "name": "cbr0",
  "plugins": [
    {
      "type": "flannel",
      "delegate": {
        "hairpinMode": true,
        "isDefaultGateway": true
      }
    },
    {
      "type": "portmap",
      "capabilities": {
        "portMappings": true
      }
    }
  ]
}

On attend quelques secondes et le pod coredns sort finalement de son pending state

7 - S'assurer de la bonne présence de Flannel :

kubectl get nodes

8 - Envoyer les fichiers suivants dans chacun des deux autres noeuds : 

scp /etc/kubernetes/pki/apiserver-kubelet-client.crt root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/apiserver-kubelet-client.key root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/ca.crt root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/ca.key root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/front-proxy-ca.crt root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/front-proxy-ca.key root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/front-proxy-client.crt root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/front-proxy-client.key root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/sa.key root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/sa.pub root@NodeNameOuIp:/etc/kubernetes/pki/
scp /etc/kubernetes/pki/etcd/ca.crt root@NodeNameOuIp:/etc/kubernetes/pki/etcd/
scp /etc/kubernetes/pki/etcd/ca.key root@NodeNameOuIp:/etc/kubernetes/pki/etcd/

9 - la commande kubeadm ini en 2) crée une commande qui permet aux autres noeuds de rejoindre le cluster. Cette commande ainsi créée est de la forme:

kubeadm join 192.168.1.100:5443 --token xxxxxx.xxxxxxx \
--discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \
--control-plane

Il faut alors rajouter ces options pour éviter une erreur à propos d'un nombre nécessaire de cpu superieur à 1 :

--ignore-preflight-errors=NumCPU 2>&1|tee $HOME/kubeadm.init.log

La commande finale permettant de rejoindre le cluster une fois créé sur le manager primaire est de la forme:

kubeadm join 192.168.1.100:5443 --token xxxxxx.xxxxxxx \
--discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \
--control-plane --ignore-preflight-errors=NumCPU 2>&1|tee $HOME/kubeadm.init.log

10 - Sur les autres noeuds manager on recopie donc cette commande afin de rejoindre le cluster créé. NB:Si le bug avec CoreDNS est aussi présent, le node qui a fraîchement rejoint le cluster ne sera pas READY state tant qu'on n'aura pas changé le fichier /etc/cni/net.d/10-flannel.conflist de la meme manière que sur le premier manager.

11 - Pour eviter des problèmes de taint, on copie-colle ces commandes sur un ou les deux derniers noeuds manager: 

mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
kubectl taint nodes --all node-role.kubernetes.io/master-

12 - Vous obtenez un cluster de 3 masters fully ready à l'emploi