Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Active/passive Loadbalancer
<a name="pacemaker-tutorial-setup2"></a>

In diesem Setup führen Sie HAProxy als Load Balancer jeweils auf einer Instance aus. Die HAProxy-Konfigurationsdateien werden im DRBD-replicated Speicher gespeichert, sodass die Konfiguration sofort verfügbar ist, wenn Pacemaker ein Failover zu einer Standby-Instanz durchführt.

**Wichtig**  
Führen Sie alle Schritte aus, [Voraussetzungen und Cluster-Setup](pacemaker-tutorial-prerequisites.md) bevor Sie fortfahren.

**Warnung**  
Führen Sie die folgenden Befehle nur auf der primären Instanz aus, sofern nicht anders angegeben.

## Installieren Sie HAProxy auf allen Instanzen
<a name="pacemaker-tutorial-setup2-install-haproxy"></a>

Installieren Sie HAProxy und deaktivieren Sie den Dienst, damit Pacemaker ihn verwalten kann. Führen Sie dies auf jeder Instanz aus.

```
sudo apt install -y haproxy
sudo systemctl disable haproxy
sudo systemctl stop haproxy
```

## Konfigurieren Sie den DRBD-Mount für HAProxy
<a name="pacemaker-tutorial-setup2-drbd-mount"></a>

Hängen Sie das DRBD-Gerät in ein Verzeichnis für den Load Balancer ein.

Erstellen Sie das Bereitstellungspunktverzeichnis. Führen Sie dies auf jeder Instanz aus.

```
sudo mkdir -p /drbd/loadbalancer/
```

Mounten Sie das DRBD-Gerät auf der primären Instanz. Hängen Sie zunächst den vorherigen Bereitstellungspunkt von den Voraussetzungen ab.

```
sudo umount /greengrass/v2
sudo mount /dev/drbd0 /drbd/loadbalancer/
```

Überprüfen Sie den Mount mit`lsblk`. Sie sollten unter `drbd0` montiert sehen`/drbd/loadbalancer`.

## HAProxy konfigurieren
<a name="pacemaker-tutorial-setup2-configure-haproxy"></a>

Die Konfigurationsdateien müssen sich im DRBD-Mount-Verzeichnis befinden, damit sie auf die Failover-Instanz repliziert werden können.

1. **Kopieren Sie die HAProxy-Konfiguration** in das DRBD-Mount-Verzeichnis.

   ```
   sudo mkdir -p /drbd/loadbalancer/etc/haproxy/
   sudo cp /etc/haproxy/haproxy.cfg /drbd/loadbalancer/etc/haproxy/haproxy.cfg
   ```

1. **Bearbeiten Sie die HAProxy-Systemd-Unit-Datei**, um die Konfiguration aus dem DRBD-Mountpfad zu verwenden. Führen Sie dies auf jeder Instanz aus.

   ```
   sudo systemctl edit haproxy
   ```

   Fügen Sie die folgenden Zeilen hinzu, um den Pfad der Konfigurationsdatei auf den DRBD-Mountpfad zu aktualisieren.

   ```
   [Service]
   Environment="CONFIG=/drbd/loadbalancer/etc/haproxy/haproxy.cfg"
   ```

1. **Laden Sie systemd neu.** Führen Sie dies auf jeder Instanz aus.

   ```
   sudo systemctl daemon-reload
   ```

## Hängen Sie die DRBD-Ressource an
<a name="pacemaker-tutorial-setup2-drbd-resource"></a>

Hängen Sie das DRBD-Gerät aus und schalten Sie DRBD herunter, damit Pacemaker es verwalten kann. Führen Sie das Unmounten auf der primären Instanz und auf allen Instanzen aus. `drbdadm down`

```
# On the primary instance only
sudo umount /drbd/loadbalancer

# On all instances
sudo drbdadm down greengrass
```

```
sudo pcs resource create drbd-greengrass \
  ocf:linbit:drbd drbd_resource=greengrass \
  op monitor interval=15s role=Promoted \
  op monitor interval=30s role=Unpromoted
```

```
sudo pcs resource promotable drbd-greengrass \
  promoted-max=1 promoted-node-max=1 clone-max=2 clone-node-max=1 notify=true
```

## Hängen Sie die Dateisystemressource an
<a name="pacemaker-tutorial-setup2-fs-resource"></a>

```
sudo pcs resource create fs_loadbalancer Filesystem \
    device="/dev/drbd0" \
    directory="/drbd/loadbalancer" \
    fstype="ext4" \
    op start timeout=15s \
    op stop timeout=15s \
    --disabled
```

## Hängen Sie die HAProxy-Systemd-Ressource an
<a name="pacemaker-tutorial-setup2-haproxy-resource"></a>

```
sudo pcs resource create haproxy systemd:haproxy \
  op monitor interval=10s \
  op start timeout=60s \
  op stop timeout=60s \
  --disabled
```

## Erstellen Sie Ressourcenbeschränkungen
<a name="pacemaker-tutorial-setup2-constraints"></a>

```
sudo pcs constraint colocation add haproxy with fs_loadbalancer
sudo pcs constraint order fs_loadbalancer then start haproxy
sudo pcs constraint colocation add fs_loadbalancer with Promoted drbd-greengrass-clone
sudo pcs constraint order promote drbd-greengrass-clone then start fs_loadbalancer
```

Aktivieren Sie die Ressourcen jetzt, da Einschränkungen gelten.

```
sudo pcs resource enable fs_loadbalancer
sudo pcs resource enable haproxy
```

Deaktivieren Sie STONITH für dieses Tutorial-Setup.

```
sudo pcs property set stonith-enabled=false
```

**Warnung**  
STONITH ist hier deaktiviert, um dieses Tutorial zu vereinfachen. In einer Produktionsumgebung müssen Sie STONITH aktivieren und einen Fencing-Agenten konfigurieren (z. B. `fence_aws` für Amazon EC2 EC2-Instances), um Split-Brain und Datenbeschädigung zu verhindern.

## Überprüfen Sie den Failover
<a name="pacemaker-tutorial-setup2-failover"></a>

1. **Überprüfen Sie den Ausgangszustand.** Stellen Sie sicher, dass HAProxy auf der primären Instanz ausgeführt wird.

   ```
   sudo pcs status
   ```

1. **Simulieren Sie einen Failover.** Versetzen Sie den Primärknoten in den Standby-Modus, um alle Ressourcen vom Primärknoten zu trennen.

   ```
   sudo pcs node standby {{primary-node-name}}
   ```

1. **Überprüfen Sie den Failover.** Überprüfen Sie auf der Standby-Instanz den Clusterstatus. Die DRBD-, Dateisystem- und HAProxy-Ressourcen sollten jetzt auf der Standby-Instanz mit aktuellen Konfigurationsdateien laufen.

   ```
   sudo pcs status
   ```

   Wenn die ausgefallene Instanz wiederhergestellt wird, bleibt der Load Balancer-Dienst auf der Standby-Instanz, es sei denn, Sie konfigurieren Pacemaker so, dass er migriert wird.

1. **Bringen Sie den Knoten wieder online.**

   ```
   sudo pcs node unstandby {{primary-node-name}}
   ```