Keepalived + Nginx = De Ergste Nachtmerrie van Downtime

De High-Availability Tango: Waarom de Moeite?

Stel je dit voor: Het is 3 uur 's nachts en je primaire server besluit dat het genoeg is geweest en valt sneller uit dan een baksteen. Zonder een goede HA-opstelling ben je in de problemen. Daar komt ons dynamische duo om de hoek kijken:

• Keepalived: De waakzame bewaker die ons virtuele IP beheert.
• Nginx: Onze betrouwbare load balancer en reverse proxy.

Samen zorgen ze ervoor dat zelfs als een server kuren krijgt, een andere naadloos overneemt. Het is alsof je een stuntman hebt voor je server - de show moet doorgaan!

De Voorbereiding: Wat Heb Je Nodig

Voordat we in de details duiken, laten we ervoor zorgen dat we alles op een rijtje hebben:

• Twee of meer servers (laten we ze node1 en node2 noemen)
• Een virtueel IP-adres (VIP) dat tussen onze servers zweeft
• Root-toegang (want we gaan serieus aan de slag)
• Basiskennis van Linux en netwerken (als je IP kunt spellen, ben je al halverwege)

Stap 1: Onze Sterspelers Installeren

Allereerst, laten we Nginx en Keepalived op beide nodes installeren. We gaan ervan uit dat je een Debian-gebaseerd systeem gebruikt, want ergens moeten we beginnen.

sudo apt update
sudo apt install nginx keepalived

Een fluitje van een cent. Nu we de tools hebben, laten we ze aan het werk zetten!

Stap 2: Nginx Configureren - De Load Balancing Maestro

Nginx zal onze frontlinie zijn, inkomende verzoeken verdelen en zorgen voor een soepele doorstroming. Laten we het instellen als een load balancer:

http {
    upstream backend {
        server 192.168.1.10:8080;
        server 192.168.1.11:8080;
    }

    server {
        listen 80;
        server_name example.com;

        location / {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

Deze configuratie vertelt Nginx om het verkeer te verdelen tussen onze twee backend-servers. Vergeet niet de IP-adressen te vervangen door je eigen server IP's!

Stap 3: Keepalived Configureren - De High-Availability Puppet Master

Nu voor de echte magie - Keepalived. Deze jongen beheert ons virtuele IP en zorgt ervoor dat het altijd naar een gezonde server wijst. Laten we het op beide nodes configureren:

Op node1 (de master):

vrrp_script chk_nginx {
    script "pidof nginx"
    interval 2
}

vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 51
    priority 101
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass supersecretpassword
    }
    virtual_ipaddress {
        192.168.1.100
    }
    track_script {
        chk_nginx
    }
}

Op node2 (de backup):

vrrp_script chk_nginx {
    script "pidof nginx"
    interval 2
}

vrrp_instance VI_1 {
    state BACKUP
    interface eth0
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass supersecretpassword
    }
    virtual_ipaddress {
        192.168.1.100
    }
    track_script {
        chk_nginx
    }
}

De belangrijkste verschillen hier zijn de state en priority instellingen. Node1 is ingesteld als MASTER met een hogere prioriteit, terwijl node2 de BACKUP is met een lagere prioriteit.

Stap 4: De Show Starten

Tijd om onze creatie tot leven te brengen! Voer op beide nodes uit:

sudo systemctl start nginx
sudo systemctl start keepalived

Als alles goed gaat, zou je nu een functionerende high-availability setup moeten hebben. Het virtuele IP (192.168.1.100 in ons voorbeeld) wordt toegewezen aan de master node.

Stap 5: Testen - Vertrouwen, maar Verifiëren

Nu voor het moment van de waarheid. Laten we ervoor zorgen dat onze setup een serveruitval aankan:

1. Controleer de IP-toewijzing opnieuw - het zou naar de andere node moeten zijn verplaatst!

Op de actieve node, stop Nginx:

sudo systemctl stop nginx

Controleer welke node momenteel het virtuele IP heeft:

ip addr show eth0

Als alles werkte zoals verwacht, gefeliciteerd! Je hebt zojuist een eenvoudige maar effectieve high-availability cluster opgezet.

Dieper Duiken: Fijn Afstemmen en Geavanceerde Concepten

Nu we een werkende setup hebben, laten we enkele manieren verkennen om het nog beter te maken:

1. Gezondheidscontroles Aanpassen

In plaats van alleen te controleren of Nginx draait, kunnen we meer geavanceerde gezondheidscontroles maken:

#!/bin/bash
# /etc/keepalived/check_nginx.sh

if [ $(ps -ef | grep -v grep | grep nginx | wc -l) -eq 0 ]; then
    exit 1
else
    curl -s -o /dev/null http://localhost
    if [ $? -eq 0 ]; then
        exit 0
    else
        exit 1
    fi
fi

Werk je Keepalived-configuratie bij om dit script te gebruiken:

vrrp_script chk_nginx {
    script "/etc/keepalived/check_nginx.sh"
    interval 2
    weight 2
}

2. Notificatiescripts Implementeren

Wil je weten wanneer failover optreedt? Laten we een notificatiescript toevoegen:

#!/bin/bash
# /etc/keepalived/notify.sh

case $1 in
    "MASTER")
        echo "$(date) - Became MASTER" >> /var/log/keepalived.log
        # Voeg hier je notificatielogica toe (bijv. stuur een e-mail of Slack-bericht)
        ;;
    "BACKUP")
        echo "$(date) - Became BACKUP" >> /var/log/keepalived.log
        ;;
    "FAULT")
        echo "$(date) - Entered FAULT state" >> /var/log/keepalived.log
        ;;
esac

Voeg dit toe aan je Keepalived-configuratie:

vrrp_instance VI_1 {
    ...
    notify /etc/keepalived/notify.sh
    ...
}

3. Meerdere Virtuele IP's

Moet je meerdere services beheren? Je kunt meerdere virtuele IP's instellen:

vrrp_instance VI_1 {
    ...
    virtual_ipaddress {
        192.168.1.100
        192.168.1.101
        192.168.1.102
    }
    ...
}

Veelvoorkomende Valkuilen en Hoe Ze te Vermijden

Zelfs de best geplande opstellingen kunnen misgaan. Hier zijn enkele veelvoorkomende problemen en hoe je ze kunt aanpakken:

1. Het Split-Brain Syndroom

Als je nodes niet kunnen communiceren, kunnen ze allebei denken dat ze de master zijn. Om dit te voorkomen:

• Gebruik een speciaal netwerk voor Keepalived-communicatie
• Implementeer fencing-mechanismen (zoals STONITH - Shoot The Other Node In The Head)

2. Inconsistente Configuraties

Zorg ervoor dat je Keepalived- en Nginx-configuraties identiek zijn op alle nodes. Overweeg het gebruik van configuratiebeheer tools zoals Ansible om consistentie te behouden.

3. Firewall Problemen

Zorg ervoor dat je firewall VRRP-verkeer (protocol 112) tussen je nodes toestaat:

sudo iptables -A INPUT -p vrrp -j ACCEPT

Naar het Volgende Niveau: Container Orchestratie

Klaar voor de grote jongens? Overweeg je HA-opstelling te integreren met container orchestratiesystemen zoals Kubernetes. Hoewel Kubernetes zijn eigen HA-mechanismen heeft, kan Keepalived nog steeds een rol spelen in het beheren van externe toegang tot je cluster.

Afronding: De Weg naar Vijf Negens

Gefeliciteerd! Je hebt een belangrijke stap gezet richting het behalen van de felbegeerde "vijf negens" van uptime. Vergeet niet dat hoge beschikbaarheid geen set-it-and-forget-it oplossing is. Regelmatig testen, monitoren en onderhoud zijn cruciaal om ervoor te zorgen dat je opstelling robuust blijft.

Enkele belangrijke punten:

• Test je failover-mechanismen regelmatig
• Monitor je Keepalived- en Nginx-logs op afwijkingen
• Houd je configuraties in versiebeheer
• Documenteer je opstelling en failoverprocedures voor je team

Met Keepalived en Nginx in je arsenaal ben je goed uitgerust om de uitdagingen van hoge beschikbaarheid aan te gaan. Zoete dromen, en moge je servers nooit slapen!

"De beste manier om falen te vermijden is om constant te falen." - Netflix

Ga nu op pad en verover die uptime-statistieken! En onthoud, in de wereld van hoge beschikbaarheid is paranoia gewoon goed plannen.