From 2402e361d28c8fe1ab9e6fbac183663f0da47f97 Mon Sep 17 00:00:00 2001 From: Svenja Michal <84835304+svenja11@users.noreply.github.com> Date: Tue, 5 Dec 2023 11:04:30 +0100 Subject: [PATCH] Update "Implementation of a Cloud HA infrastructure with Keepalived" (#737) Fix #733 --- .../configure-cloud-ha-keepalived/01.de.md | 163 +++++++++-------- .../configure-cloud-ha-keepalived/01.en.md | 167 +++++++++--------- 2 files changed, 172 insertions(+), 158 deletions(-) diff --git a/tutorials/configure-cloud-ha-keepalived/01.de.md b/tutorials/configure-cloud-ha-keepalived/01.de.md index 6d4323ea6..52b7e1216 100644 --- a/tutorials/configure-cloud-ha-keepalived/01.de.md +++ b/tutorials/configure-cloud-ha-keepalived/01.de.md @@ -4,7 +4,7 @@ path: "/tutorials/configure-cloud-ha-keepalived/de" slug: "configure-cloud-ha-keepalived" date: "2021-05-19" title: "Umsetzung einer Cloud HA Infrastruktur mit Keepalived" -short_description: "Konfiguration einer HA Struktur in der Cloud mithilfe von Floating-IPs und Keepalived" +short_description: "Konfiguration einer HA Struktur in der Cloud mithilfe von Floating IPs und Keepalived" tags: ["HA", "Lang:Go", "linux", "keepalived", "floating-ip", "cloud"] author: "Markus" author_link: "https://github.com/BackInBash" @@ -17,121 +17,113 @@ header_img: "header-8" ## Einleitung -In diesem Tutorial wird die Einrichtung eines Cloud HA Clusters mithilfe von Keepalived und Floating-IPs beschrieben. +In diesem Tutorial wird die Einrichtung eines Cloud HA Clusters mithilfe von Keepalived und Floating IPs beschrieben. Das Tutorial wird als Beispiel anhand von zwei Servern erklärt. Sollte der erste (originale) Server nicht mehr erreichbar sein, wird die Floating IP automatisch dem zweiten "Ersatz"-Server zugewiesen. Sobald der originale Server wieder erreichbar ist, wird die Floating IP automatisch wieder diesem zugewiesen. Dadurch bleibt die Anwendung auch dann erreichbar, wenn der Server ausfällt. -Zu beachten ist das diese form der Hochverfügbarkeit nicht von allen Anwendungen unterstützt wird. Dies sollte im ersten Schritt geprüft werden. +Zu beachten ist, dass diese Form der Hochverfügbarkeit nicht von allen Anwendungen unterstützt wird. Dies sollte im ersten Schritt geprüft werden. **Voraussetzungen** -+ min. 2 Cloud Server -+ Eine Floating-IP ++ Min. 2 Cloud Server ++ Eine Floating IP **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. +> 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. +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. +Dieser Token wird benötigt um später vom Server aus die Floating IP Zuweisung zu steuern. -In der Cloud Console muss unter **"Sicherheit"** --> **"API-Tokens"** ein **Lese/Schreib** API Token angelegt werden. +In der Cloud Console muss unter **"Sicherheit"** » **"API-Tokens"** ein **Lese/Schreib** API Token angelegt werden. ![](images/api.png) -> Hinweis: Da der Token nur einmal ausgelesen werden kann empfiehlt es sich diesen zwischenzuspeichern. +> **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. +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. +Solch 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. +Hier kann ein Netzwerk mit beliebiger Größe (größer 32) angelegt und den beiden Server auch gleich zugewiesen werden. ![](images/network.png) ### 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. +In diesem Schritt wird auf beiden Servern 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](https://github.com/FootprintDev/hcloud-ip) um die Software zu installieren kann entweder auf die prebuilt-Binaries zurückgegriffen werden oder man kompiliert die Software selbst. +Dabei handelt es sich um die Open Source Software [hcloud-ip](https://github.com/FootprintDev/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** ```bash wget -O /opt/hcloud-ip https://github.com/FootprintDev/hcloud-ip/releases/download/v0.0.1/hcloud-ip-linux64 -chmod +x /opt/hcloud +chmod +x /opt/hcloud-ip ``` -**Um die Software selbst zu kompiliert sind folgende Schritte notwendig** +**Um die Software selbst zu kompilieren, sind folgende Schritte notwendig** 1. Installation der Abhängigkeiten - -Ubuntu / Debian: - -```bash -apt install git wget -``` - -CentOS / RHEL: - -```bash -yum install git wget -``` - -Fedora: - -```bash -dnf instal git wget -``` - -openSUSE / SLES: - -```bash -zypper install git wget -``` + + Ubuntu / Debian: + ```bash + apt install git wget + ``` + + CentOS / RHEL: + ```bash + yum install git wget + ``` + + Fedora: + ```bash + dnf instal git wget + ``` + + openSUSE / SLES: + ```bash + zypper install git wget + ``` 2. Golang Installation - -```bash -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 -``` + ```bash + wget https://go.dev/dl/go1.21.4.linux-amd64.tar.gz + tar xfvz go1.21.4.linux-amd64.tar.gz + export PATH=$(pwd)/go/bin:$PATH + ``` 3. Clonen des Repositories - -```bash -git clone https://github.com/FootprintDev/hcloud-ip /tmp/hcloud-ip && cd /tmp/hcloud-ip -``` + ```bash + git clone https://github.com/FootprintDev/hcloud-ip /tmp/hcloud-ip && cd /tmp/hcloud-ip + ``` 4. Projekt Bauen + ```bash + go build + ``` -```bash -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. +Nun sollte sich im aktuellen Ordner ein Programm mit dem Namen `hcloud-ip` befinden. Dies kann entsprechend ausführbar gemacht und abgespeichert werden. ```bash chmod +x hcloud-ip mv hcloud-ip /opt ``` -### Schritt 1.4 - Konfiguration der Floating-IP +### 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](https://docs.hetzner.com/cloud/floating-ips/persistent-configuration) +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](https://docs.hetzner.com/de/cloud/floating-ips/persistent-configuration/) ## Schritt 2 - Einrichtung von Keepalived -Keepalived ist ein Linux Daemon der Systeme oder Dienste überwacht und im Fehlerfall ein Failover anstößt. +Keepalived ist ein Linux Daemon der Systeme oder Dienste überwacht und im Fehlerfall ein Failover anstößt. Keepalived muss auf beiden Servern installiert werden. ### Schritt 2.1 - Installation von Keepalived @@ -177,18 +169,19 @@ chkconfig keepalived on Die hier gezeigte Konfiguration entspricht einem Beispiel anhand eines HA Webservers (nginx). -**Konfiguration des Master Servers** +**Konfiguration auf dem Master Server** `/etc/keepalived/keepalived.conf` -```Console +```conf vrrp_script chk_nginx { script "/usr/bin/pgrep nginx" interval 2 + weight 101 } vrrp_instance VI_1 { - interface [cloud_network_adapter] + interface [cloud_private_network_adapter] state MASTER priority 200 @@ -200,7 +193,7 @@ vrrp_instance VI_1 { authentication { auth_type PASS - auth_pass [password] + auth_pass [random_password] } track_script { @@ -211,20 +204,20 @@ vrrp_instance VI_1 { } ``` -> Hinweis: Die umrandeten Werte `[]` sind durch eigene Angaben auszutauschen. +> **Hinweis:** Die umrandeten Werte `[]` sind durch eigene Angaben auszutauschen. Für `auth_pass` kann ein beliebiges Passwort gewählt werden. Für den Master und den Slave sollte aber dasselbe Passwort angegeben werden. -**Konfiguration des Slave Servers** +**Konfiguration auf dem Slave Server** `/etc/keepalived/keepalived.conf` -```Console +```conf vrrp_script chk_nginx { script "/usr/bin/pgrep nginx" interval 2 } vrrp_instance VI_1 { - interface [cloud_network_adapter] + interface [cloud_private_network_adapter] state SLAVE priority 100 @@ -236,7 +229,7 @@ vrrp_instance VI_1 { authentication { auth_type PASS - auth_pass [password] + auth_pass [random_password] } track_script { @@ -247,13 +240,15 @@ vrrp_instance VI_1 { } ``` -> Hinweis: Die umrandeten Werte `[]` sind durch eigene Angaben auszutauschen. +> **Hinweis:** Die umrandeten Werte `[]` sind durch eigene Angaben auszutauschen. Für `auth_pass` kann ein beliebiges Passwort gewählt werden. Für den Master und den Slave sollte aber dasselbe Passwort angegeben werden. -**Inhalt der `failover.sh`** +**Inhalt der `failover.sh` auf beiden Servern** -Das Script beinhaltet die Aktionen die bei einem Failover ausgeführt werden sollen. +`/etc/keepalived/failover.sh` -```bash +Das Script beinhaltet die Aktionen, die bei einem Failover ausgeführt werden sollen. + +```sh #!/bin/bash IP='[Floating-IP-Name]' TOKEN='[CloudToken]' @@ -269,7 +264,19 @@ do done ``` -> Hinweis: Die umrandeten Werte `[]` sind durch eigene Angaben auszutauschen. +> **Hinweis:** Die umrandeten Werte `[]` sind durch eigene Angaben auszutauschen. + +Die Datei kann nun ausführbar gemacht werden: + +```bash +chmod 755 /etc/keepalived/failover.sh +``` + +Auf systemd basierten Systemen kann Keepalived jetzt gestartet werden: + +```bash +systemctl start keepalived +``` ## Schritt 3 - Testen der Konfiguration @@ -283,9 +290,9 @@ 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 +## Ergebnis -In diesem Beitrag wird beschreiben wie man eine High Availability Cloud Umgebung mithilfe von keepalived erstellt. +Die High Availability Cloud Umgebung sollte nun erstellt sein. ##### License: MIT diff --git a/tutorials/configure-cloud-ha-keepalived/01.en.md b/tutorials/configure-cloud-ha-keepalived/01.en.md index aab9744d5..fd5ec035e 100644 --- a/tutorials/configure-cloud-ha-keepalived/01.en.md +++ b/tutorials/configure-cloud-ha-keepalived/01.en.md @@ -4,8 +4,8 @@ path: "/tutorials/configure-cloud-ha-keepalived" slug: "configure-cloud-ha-keepalived" date: "2021-05-19" title: "Implementation of a Cloud HA infrastructure with Keepalived" -short_description: "Configuring an HA structure in the cloud using floating IPs and keepalived" -tags: ["HA", "Lang:Go", "linux", "keepalived", "floating-ip", "cloud"] +short_description: "Configuring an HA structure in the cloud using Floating IPs and keepalived" +tags: ["HA", "Lang:Go", "linux", "keepalived", "Floating IP", "cloud"] author: "Markus" author_link: "https://github.com/BackInBash" author_img: "https://avatars3.githubusercontent.com/u/48181660" @@ -17,120 +17,112 @@ header_img: "header-8" ## Introduction -This tutorial describes how to set up a Cloud HA cluster using keepalived and floating IPs. +This tutorial describes how to set up a Cloud HA cluster using keepalived and Floating IPs. The tutorials uses two servers as an example. If the first (original) server fails, the Floating IP is automatically assigned to the second server. As soon as the original server is available again, the Floating IP is automatically assigned back to the first server. This ensures that the web application is still available even if the server fails. It should be noted that this form of high availability is not supported by all applications. This should be checked in the first place. -**Requirements** +**Prerequisites** -+ min. 2 Cloud-Server -+ One Floating-IP ++ Min. 2 cloud servers ++ One Floating IP -**Recommendation** +**Recommended** ->A separate cloud project should be created for the HA service, since **critical** access data must be stored in **clear text** on the servers. - ->With a separate project, the damage can be minimized in the event of a possible compromise. +> A separate cloud project should be created for the HA service, since **critical** access data must be stored in **clear text** on the servers. +> With a separate project, the damage can be minimized in the event of a possible compromise. ## Step 1 - Setting up automatic IP rerouting -This step is about automatic failover, where the floating IP is automatically assigned to the other server. So that the service can operate under the same address. +This step is about automatic failover, where the Floating IP is automatically assigned to the other server, so that the service can operate under the same address. ### Step 1.1 - Creation of a Cloud API token -This token is required to later control the floating IP assignment from the server. -In the Cloud Console, a **read/write** API token must be created under **"Security"** --> **"API tokens"**. +This token is required to control the Floating IP assignment from the server. +In the Cloud Console, a **read/write** API token must be created under **"Security"** » **"API tokens"**. ![](images/api.png) -> Note: Since the token can only be read once, it is recommended to store it temporarily. +> **Note:** Since the token can only be read once, it is recommended to store it temporarily. -### Step 1.2 - Create a cloud network +### Step 1.2 - Create a Cloud Network -For the `VRRP` Heartbeat a private network channel is needed this is realized via the function of the cloud networks. +For the `VRRP` Heartbeat, a private network channel is needed. For this, Cloud Networks are used. -Such a cloud network can be created in the Cloud Console under "Networks". +You can create a Cloud Network in the Cloud Console under "Networks". -Here a network with arbitrary size (larger 32) can be created and also assigned to the servers. +There, you can create a Network and assign it to the servers. ![](images/network.png) ### Step 1.3 - Installing the IP Failover Software -In this step, the software responsible for provisioning the floating IP is installed. +In this step, the software responsible for provisioning the Floating IP is installed on both servers. -This is a open source software [hcloud-ip](https://github.com/FootprintDev/hcloud-ip) to install the software, you can either use the prebuilt binaries or compile the software yourself. +This is the open-source software [hcloud-ip](https://github.com/FootprintDev/hcloud-ip). To install the software, you can either use the prebuilt binaries or compile the software yourself. -**For an installation with the prebuilt binaries the following steps are necessary** +**For an installation with the prebuilt binaries, the following steps are necessary** ```bash wget -O /opt/hcloud-ip https://github.com/FootprintDev/hcloud-ip/releases/download/v0.0.1/hcloud-ip-linux64 -chmod +x /opt/hcloud +chmod +x /opt/hcloud-ip ``` -**To compile the software yourself the following steps are necessary** +**To compile the software yourself, the following steps are necessary** 1. Installing the dependencies - -Ubuntu / Debian: - -```bash -apt install git wget -``` - -CentOS / RHEL: - -```bash -yum install git wget -``` - -Fedora: - -```bash -dnf instal git wget -``` - -openSUSE / SLES: - -```bash -zypper install git wget -``` + + Ubuntu / Debian: + ```bash + apt install git wget + ``` + + CentOS / RHEL: + ```bash + yum install git wget + ``` + + Fedora: + ```bash + dnf instal git wget + ``` + + openSUSE / SLES: + ```bash + zypper install git wget + ``` 2. Golang installation - -```bash -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 -``` + ```bash + wget https://go.dev/dl/go1.21.4.linux-amd64.tar.gz + tar xfvz go1.21.4.linux-amd64.tar.gz + export PATH=$(pwd)/go/bin:$PATH + ``` 3. Cloning the repository - -```bash -git clone https://github.com/FootprintDev/hcloud-ip /tmp/hcloud-ip && cd /tmp/hcloud-ip -``` + ```bash + git clone https://github.com/FootprintDev/hcloud-ip /tmp/hcloud-ip && cd /tmp/hcloud-ip + ``` 4. Build the Project + ```bash + go build + ``` -```bash -go build -``` - -Now there should be a program named `hcloud-ip` in the current folder, this can be made executable and saved respectively. +Now there should be a program named `hcloud-ip` in the current folder. You can make it executable and save it respectively. ```bash chmod +x hcloud-ip mv hcloud-ip /opt ``` -### Step 1.4 - Configuring the floating IP +### Step 1.4 - Configuring the Floating IP -In order for the floating IP to work on all servers in the event of a failover, it must be included in the network configuration. -Instructions for this can be found at [docs.hetzner.com](https://docs.hetzner.com/cloud/floating-ips/persistent-configuration). +In order for the Floating IP to work on all servers in the event of a failover, you need to include it in the network configuration. +You can find instructions for this at [docs.hetzner.com](https://docs.hetzner.com/cloud/floating-ips/persistent-configuration). ## Step 2 - Setting up Keepalived -Keepalived is a Linux daemon that monitors systems or services and triggers a failover in case of an error. +Keepalived is a Linux daemon that monitors systems or services and triggers a failover in case of an error. You need to install it on both servers. ### Step 2.1 - Installing Keepalived @@ -176,18 +168,19 @@ chkconfig keepalived on The configuration shown here corresponds to an example using an HA web server (nginx). -**Configuration of the master server** +**Configuration file on the master server** `/etc/keepalived/keepalived.conf` -```Console +```conf vrrp_script chk_nginx { script "/usr/bin/pgrep nginx" interval 2 + weight 101 } vrrp_instance VI_1 { - interface [cloud_network_adapter] + interface [cloud_private_network_adapter] state MASTER priority 200 @@ -199,7 +192,7 @@ vrrp_instance VI_1 { authentication { auth_type PASS - auth_pass [password] + auth_pass [random_password] } track_script { @@ -210,20 +203,20 @@ vrrp_instance VI_1 { } ``` -> Note: The outlined values `[]` are to be replaced by your own specifications. +> **Note:** The outlined values `[]` are to be replaced by your own specifications. For `auth_pass`, you can pick any random password. However, make sure to use the same password for the master and the slave. -**Configuration of the slave server** +**Configuration file on the slave server** `/etc/keepalived/keepalived.conf` -```Console +```conf vrrp_script chk_nginx { script "/usr/bin/pgrep nginx" interval 2 } vrrp_instance VI_1 { - interface [cloud_network_adapter] + interface [cloud_private_network_adapter] state SLAVE priority 100 @@ -235,7 +228,7 @@ vrrp_instance VI_1 { authentication { auth_type PASS - auth_pass [password] + auth_pass [random_password] } track_script { @@ -246,13 +239,15 @@ vrrp_instance VI_1 { } ``` -> Note: The outlined values `[]` are to be replaced by your own specifications. +> **Note:** The outlined values `[]` are to be replaced by your own specifications. For `auth_pass`, you can pick any random password. However, make sure to use the same password for the master and the slave. -**Contents of `failover.sh`** +**Contents of `failover.sh` on both servers** + +`/etc/keepalived/failover.sh` The script contains the actions that are to be executed in the event of a failover. -```bash +```sh #!/bin/bash IP='[Floating-IP-Name]' TOKEN='[CloudToken]' @@ -268,7 +263,19 @@ do done ``` -> Note: The outlined values `[]` are to be replaced by your own specifications. +> **Note:** The outlined values `[]` are to be replaced by your own specifications. + +Make the `failover.sh` file executable: + +```bash +chmod 755 /etc/keepalived/failover.sh +``` + +On systemd based systems, you can now start keepalived: + +```bash +systemctl start keepalived +``` ## Step 3 - Testing the configuration @@ -284,7 +291,7 @@ As soon as the master web server is reachable again, it is switched back to. ## Conclusion -In this post we will describe how to create a High Availability Cloud environment using keepalived. +You should now have a High Availability Cloud environment. ##### License: MIT