home..

Umsetzung einer Cloud HA Infrastruktur mit Keepalived

Markus Brunsch / May 2021

Konfiguration einer HA Struktur in der Cloud mithilfe von Floating-IPs und Keepalived

In diesem Tutorial wird die Einrichtung eines Cloud HA Clusters mithilfe von Keepalived und Floating-IPs beschrieben.

Zu beachten ist das diese form der Hochverfügbarkeit nicht von allen Anwendungen unterstützt wird. Dies sollte im ersten Schritt geprüft werden.

Voraussetzungen

Empfehlung

Für den HA Service sollte ein eigenes Cloud Projekt angelegt werden, da auf den Servern kritische Zugangsdaten im klartext abgelegt werden müssen. Mit einem seperaten Projekt kann bei einer möglichen kompromitierung der Schaden minimiert werden.

Schritt 1 - Einrichtung des automatischen IP Rerouting

In diesem Schritt geht es um das automatische Failover, dabei soll die Floating-IP automatisch dem anderen Server zugewiesen werden. Damit dieser unter der gleichen Adresse den ausgefallenen Dienst wieder aufnehmen stellen kann.

Schritt 1.1 - Erstellung eines Cloud API Tokens

Dieser Token wird benötigt um später vom Server aus die Floating-IP zuordnung zu steuern.

In der Cloud Console muss unter “Sicherheit” –> “API-Tokens” ein Lese/Schreib API Token angelegt werden.

Hinweis: Da der Token nur einmal ausgelesen werden kann empfiehlt es sich diesen zwischenzuspeichern.

Schritt 1.2 - Anlegen eines Cloud Netzwerks

Für den VRRP Heartbeat wird ein privater Netzwerkkanal benötigt dieser wird über die Funktion der Cloud Netzwerke realisiert.

Solche ein Cloud Netzwerk kann in der Cloud Console unter “Netzwerke” angelegt werden.

Hier kann ein Netzwerk mit beliebiger größe (größer 32) angelegt und den beiden Server auch gleich zugewiesen werden.

Schritt 1.3 - Installation der IP Failover Software

In diesm Schritt wird die Software installiert, die für die Provisionierung der Floating-IP zuständig ist.

Dabei handelt es sich um die Open Source Software hcloud-ip um die Software zu installieren kann entweder auf die prebuilt-Binaries zurückgegriffen werden oder man kompiliert die Software selbst.

Für eine installation mit den prebuilt-Binaries sind folgende Schritte notwendig

wget -O /opt/hcloud-ip https://github.com/FootprintDev/hcloud-ip/releases/download/v0.0.1/hcloud-ip-linux64
chmod +x /opt/hcloud

Um die Software selbst zu kompiliert sind folgende Schritte notwendig

  1. Installation der Abhängigkeiten

Ubuntu / Debian:

apt install git wget

CentOS / RHEL:

yum install git wget

Fedora:

dnf instal git wget

openSUSE / SLES:

zypper install git wget
  1. Golang Installation
wget https://golang.org/dl/go1.16.2.linux-amd64.tar.gz
tar xfvz go1.16.2.linux-amd64.tar.gz
export PATH=$(pwd)/go/bin:$PATH
  1. Clonen des Repositories
git clone https://github.com/FootprintDev/hcloud-ip /tmp/hcloud-ip && cd /tmp/hcloud-ip
  1. Projekt Bauen
go build

Nun sollte sich im aktuellen Ordner ein Programm mit dem Namen hcloud-ip befinden, dies kann entsprechend ausführbar gemacht und abgespeichert werden.

chmod +x hcloud-ip
mv hcloud-ip /opt

Schritt 1.4 - Konfiguration der Floating-IP

Damit die Floating-IP bei einem Failover auf allen Servern funktioniert, muss diese in die Netzwerkkonfiguration aufgenommen werden. Eine Anleitung hierfür befindet sich auf docs.hetzner.com

Schritt 2 - Einrichtung von Keepalived

Keepalived ist ein Linux Daemon der Systeme oder Dienste überwacht und im Fehlerfall ein Failover anstößt.

Schritt 2.1 - Installation von Keepalived

Ubuntu / Debian:

apt install keepalived

CentOS / RHEL:

yum install keepalived

Fedora:

dnf instal keepalived

openSUSE / SLES:

zypper install keepalived

Schritt 2.2 - Keepalived autostart aktivieren

Systemd basierte Systeme:

systemctl enable keepalived

CentOS / RHEL

chkconfig keepalived on

Schritt 2.3 - Konfiguration von Keepalived

Die hier gezeigte Konfiguration entspricht einem Beispiel anhand eines HA Webservers (nginx).

Konfiguration des Master Servers

/etc/keepalived/keepalived.conf

vrrp_script chk_nginx {
    script "/usr/bin/pgrep nginx"
    interval 2
}

vrrp_instance VI_1 {
    interface [cloud_network_adapter]
    state MASTER
    priority 200

    virtual_router_id 30
    unicast_src_ip [master_private_IP]
    unicast_peer {
        [slave_private_IP]
    }

    authentication {
        auth_type PASS
        auth_pass [password]
    }

    track_script {
        chk_nginx
    }

    notify_master /etc/keepalived/failover.sh
}

Hinweis: Die umrandeten Werte [] sind durch eigene Angaben auszutauschen.

Konfiguration des Slave Servers

/etc/keepalived/keepalived.conf

vrrp_script chk_nginx {
    script "/usr/bin/pgrep nginx"
    interval 2
}

vrrp_instance VI_1 {
    interface [cloud_network_adapter]
    state SLAVE
    priority 100

    virtual_router_id 30
    unicast_src_ip [slave_private_IP]
    unicast_peer {
        [master_private_IP]
    }

    authentication {
        auth_type PASS
        auth_pass [password]
    }

    track_script {
        chk_nginx
    }

    notify_master /etc/keepalived/failover.sh
}

Hinweis: Die umrandeten Werte [] sind durch eigene Angaben auszutauschen.

Inhalt der failover.sh

Das Script beinhaltet die Aktionen die bei einem Failover ausgeführt werden sollen.

#!/bin/bash
IP='[Floating-IP-Name]'
TOKEN='[CloudToken]'
n=0
while [ $n -lt 10 ]
do
    if [ "$(/opt/hcloud-ip -ip $IP -key $TOKEN)" == "Server called $HOSTNAME was found" ]; then
        break
    fi
    n=$((n+1))
    sleep 3
done

Hinweis: Die umrandeten Werte [] sind durch eigene Angaben auszutauschen.

Schritt 3 - Testen der Konfiguration

Im Normalbetrieb übernimmt der Master Webserver alle Anfragen.

Sobald dieser ausfällt gibt es ein Failover auf den Slave Webserver.

Sobald der Master Webserver wieder erreichbar ist wird wieder auf diesen gewechselt.

Fazit

In diesem Beitrag wird beschreiben wie man eine High Availability Cloud Umgebung mithilfe von keepalived erstellt.

© 2023 Markus Brunsch