Einfache Installation von Kubernetes mit HA – 8 Server

kubernetes,kubernetes cluster,kubernetes ha cluster,kubernetes installation on bare metal,kubernetes installieren » beyond.lol

Hier zeigen wir Euch, wie Ihr die Installation von Kubernetes mit HA durchführt. Was Kubernetes genau ist, könnt Ihr unter Kubernetes.io nachlesen. Der Kubernetes Cluster benötigt im gesamten 8 Server. Zum Testen können das aber natürlich auch einfach 8 virtuelle Maschinen sein. 2 Maschinen benötigen wir für Keepalived und HAProxy, dann erstellen wir 3 Master- und 3 Worker-Server.

IP und Ubuntu 20 Setup

Als erstes erstellen wir uns eine IP-Liste für das Setup der einzelnen Server. In unserem LAB sieht die IP-Vergabe in etwa so aus. Die Floating IP wird bei einem Ausfall eines Loadbalancers mittels Keepalived an den anderen Loadbalancer übergeben.

ServernameIP-Adresse
Loadbalancer 1 (lb1)192.168.0.70
Loadbalancer 2 (lb2)192.168.0.71
Floating IP192.168.0.111
Master 1 (master1)192.168.0.72
Master 2 (master2)192.168.0.73
Master 3 (master3)192.168.0.74
Worker 1 (worker1)192.168.0.75
Worker 2 (worker2)192.168.0.76
Worker 3 (worker3)192.168.0.77
IP-Setup für die Installation von Kubernetes mit HA

Installation der Loadbalancer

Wie bereits erwähnt wird im Falle eines Ausfalls eines Loadbalancers die IP an den anderen Loadbalancer übergeben. Hierfür müssen wir Keepalived und HAProxy installieren, was mit dem folgenden Befehl auf dem lb1 und lb2 ausgeführt wird:

apt install keepalived haproxy psmisc -y

Nun konfigurieren wir als erstes HAProxy auf beiden Loadbalancern. Die Konfiguration ist auf beiden Servern identisch:

vi /etc/haproxy/haproxy.cfg
global
    log /dev/log  local0 warning
    chroot      /var/lib/haproxy
    pidfile     /var/run/haproxy.pid
    maxconn     4000
    user        haproxy
    group       haproxy
    daemon
   
   stats socket /var/lib/haproxy/stats
   
defaults
  log global
  option  httplog
  option  dontlognull
        timeout connect 5000
        timeout client 50000
        timeout server 50000
   
frontend kube-apiserver
  bind *:6443
  mode tcp
  option tcplog
  default_backend kube-apiserver
   
backend kube-apiserver
    mode tcp
    option tcplog
    option tcp-check
    balance roundrobin
    default-server inter 10s downinter 5s rise 2 fall 2 slowstart 60s maxconn 250 maxqueue 256 weight 100
    server kube-apiserver-1 192.168.0.72:6443 check #Mit deiner Master 1 IP ersetzen
    server kube-apiserver-2 192.168.0.73:6443 check #Mit deiner Master 2 IP ersetzen
    server kube-apiserver-3 192.168.0.74:6443 check #Mit deiner Master 3 IP ersetzen

anschliessend die Konfiguration speichern und neustarten. Anschliesend auch nach reboots verfügbar machen.

systemctl restart haproxy
systemctl enable haproxy

Konfiguration von Keepalived

Als erstes erstellen wir ein Konfigurationsfile auf dem LB1:

vi /etc/keepalived/keepalived.conf

Folgende Konfiguration einfügen und anpassen:

global_defs {
  notification_email {
  }
  router_id LVS_DEVEL
  vrrp_skip_check_adv_addr
  vrrp_garp_interval 0
  vrrp_gna_interval 0
}
   
vrrp_script chk_haproxy {
  script "killall -0 haproxy"
  interval 2
  weight 2
}
   
vrrp_instance haproxy-vip {
  state BACKUP
  priority 100
  interface eth0                       # Netzwerkkarte
  virtual_router_id 60
  advert_int 1
  authentication {
    auth_type PASS
    auth_pass 1111
  }
  unicast_src_ip 192.168.0.70      # Die Eigene IP-Adresse
  unicast_peer {
    192.168.0.71                         # Die IP-Adresse anderer Loadbalancer
  }
   
  virtual_ipaddress {
    192.168.0.111/24                  # Die Floating IP
  }
   
  track_script {
    chk_haproxy
  }
}

Die Konfiguration speichern und ebenfalls nach dem Neustart verfügbar machen:

systemctl restart keepalived
systemctl enable keepalived

Nun nicht vergessen die Konfiguration auf den Loadbalancer 2 ebenfalls auszuführen, hier drehen sich die IPs von unicast_peer und unicast_src_ip natürlich um.

Prüfen der Hochverfügbarkeit

Die Hochverfügbarkeit können wir ganz schnell überprüfen indem wir auf dem Loadbalancer1 folgenden Befehl eingeben:

ip a s

Nun sollte die Floating IP auftauchen (192.168.0.111). Ist dies der Fall stellen wir den Server mittels

systemctl stop haproxy

ab und testen, ob die Floating IP auf den Loadbalancer 2 gesprungen ist. Also auf dem Loadbalancer 2 ebenfalls diesen Befehl

ip a s

eingeben und sehen ob dieser nun die Floating IP bekommen hat. Ist dies der Fall können wir endlich mit der Installation des Kubernetes Clusters beginnnen.

Installation des Kubernetes Clusters

Für die Installation von Kubernetes nutzen wir KubeKey. Dieser ist sehr einfach zu nutzen und die Installation geht somit eigentlich recht flott.

Als Erstes laden wir Kubekey von GitHub mittels curl auf einen unserer Masterserver herunter.

curl -sfL https://get-kk.kubesphere.io | VERSION=v2.0.0 sh -

anschliessend machen wir KubeKey ausführbar und erstellen ein Konfigurationsfile mit den folgenden Befehlen:

chmod +x kk
./kk create config --with-kubesphere v3.2.1 --with-kubernetes v1.21.5

Das erstellte YAML-File öffnen wir mit folgendem Befehl:

vi config-sample.yaml

Folgender Konfigurationsblock sollte in etwa so aussehen:

...
spec:
  hosts:
  - {name: master1, address: 192.168.0.72, internalAddress: 192.168.0.72, user: root, password: PasswOrd}
  - {name: master2, address: 192.168.0.73, internalAddress: 192.168.0.73, user: root, password: PasswOrd}
  - {name: master3, address: 192.168.0.74, internalAddress: 192.168.0.74, user: root, password: PasswOrd}
  - {name: worker1, address: 192.168.0.75, internalAddress: 192.168.0.75, user: root, password: PasswOrd}
  - {name: worker2, address: 192.168.0.76, internalAddress: 192.168.0.76, user: root, password: PasswOrd}
  - {name: worker3, address: 192.168.0.77, internalAddress: 192.168.0.77, user: root, password: PasswOrd}
  roleGroups:
    etcd:
    - master1
    - master2
    - master3
    control-plane:
    - master1
    - master2
    - master3
    worker:
    - worker1
    - worker2
    - worker3
  controlPlaneEndpoint:
    domain: lb.kubesphere.local
    address: 192.168.0.111   # Floating IP hier eintragen
    port: 6443
...

speichern und schliessen.

Anschliessend können wir den Cluster mit folgendem Befehl initialisieren:

./kk create cluster -f config-sample.yaml

Als erstes laufen ein paar pre-checks wie ob mit den Benutzerangaben eingeloggt werden kann und ob Packete fehlen. Fehlende Packete gibt KubeKey aus und müssen dann auf jedem Node, welchem das Paket fehlt, nachinstalliert werden. Die Installationskandidaten habe ich euch hier aufgelistet:

gewünschtes PacketInstallationskandidat
Socatapt install socat
Chronyapt install chrony
IPsetapt install ipset
Conntrackapt install conntrack
NFS-Clientapt install nfs-client
Installationskandidaten für die Installation von Kubernetes mit HA

sind alle gewünschten Pakete installiert kann man mit yes bestätigen und schon gehts los. Je nach dem wie der Server ausgestattet ist, kann man erstmal Kaffe trinken gehen.

Wenn anschliessend alles ungefähr so aussieht wie unten war die Installation erfolgreich und Ihr könnt euch einloggen und loslegen. Wie Ihr seht geht die Installation von Kubernetes mit HA eigentlich ganz easy und dauert auch gar nicht mal so lange.

Die mobile Version verlassen