Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: Quorum und Split-Brain

Ziel: Du weißt aus eigener Anschauung, wann DRBD weiterschreibt, wann es anhält und wann es einen alten Primary absetzt – und du löst ein echtes Split-Brain auf, ohne die falschen Daten zu behalten. · Dauer: ca. 75 min · Voraussetzung: Tag 10

Briefing

  • Jede Ressource aus rg-k8s hat drei Stimmen: zwei Kopien und den Tiebreaker auf der Witness. Schreiben darf nur, wer die Mehrheit sieht (quorum majority).
  • Ohne Mehrheit hält der Primary alle Schreibvorgänge an (on-no-quorum suspend-io).
  • Hat die Mehrheit inzwischen weitergeschrieben, wird der alte Primary abgesetzt (on-suspended-primary-outdated force-secondary).
  • Ohne Quorum gibt es diesen Schutz nicht – dann droht Split-Brain.
  • Alle Versuche laufen an Test-Ressourcen, nicht an demo.
 Versuch A  Secondary verliert Storage-Netz        -> Primary schreibt weiter
 Versuch B  Primary verliert Storage-Netz          -> Witness entscheidet
 Versuch C  Primary verliert alles                 -> suspended:quorum
 Versuch D  Gegenseite übernimmt während C         -> force-secondary, I/O-Fehler
 Versuch E  Ressource ohne Quorum                  -> Split-Brain, StandAlone
Quorum mit Witness: wer weiterschreiben darf und wie Split-Brain entsteht

Drill 1: Der Versuchsaufbau

rg-k8s hat seit Tag 8 keine Volume-Group mehr, spawn-resources taugt also nicht. Du legst die Ressource in drei Schritten an; sie erbt alle Einstellungen der Gruppe:

# auf k0s-ctrl
mkdir -p ~/k0s-lab/tag11 && cd ~/k0s-lab/tag11
linstor resource-definition create qtest --resource-group rg-k8s
linstor volume-definition create qtest 300M
linstor resource create qtest --auto-place 2
linstor --no-utf8 --no-color resource list -r qtest | cut -c16-

Erwartet (gekürzt):

    Tie breaker resource 'qtest' created on k0s-ctrl
...
| k0s-ctrl | DRBD,STORAGE            | Unused | Ok    |     Diskless | Yes  |
| k0s-w1   | DRBD,WRITECACHE,STORAGE | Unused | Ok    |     UpToDate | Yes  |
| k0s-w2   | DRBD,WRITECACHE,STORAGE | Unused | Ok    | Inconsistent | Yes  |

Inconsistent ist der erste Resync, nach wenigen Sekunden steht auch dort UpToDate. Auf dem Primary läuft ein Schreiber, der jede Sekunde einen Zeitstempel anhängt und sofort sync aufruft. Lücken in der Datei zeigen später jede Schreibpause:

# auf k0s-w1
sudo mkfs.ext4 -q /dev/drbd/by-res/qtest/0
sudo mkdir -p /mnt/qtest
sudo mount /dev/drbd/by-res/qtest/0 /mnt/qtest
sudo systemd-run --unit=schreiber bash -c 'while true; do
  date +%T.%N | cut -c1-12 >> /mnt/qtest/log; sync /mnt/qtest/log; sleep 1; done'
sudo drbdadm status qtest

Erwartet:

Running as unit: schreiber.service; invocation ID: 242592f7ccf3447e8c8f9bd151958bec
qtest role:Primary
  disk:UpToDate open:yes
  k0s-ctrl role:Secondary
    peer-disk:Diskless peer-client:yes
  k0s-w2 role:Secondary
    peer-disk:UpToDate

/dev/drbd/by-res/<name>/0 erspart dir die Minor-Nummer. Beim Mounten wird der Node automatisch Primary (auto-promote). systemd-run hält den Schreiber am Leben, wenn deine SSH-Sitzung endet.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Versuch A – ein Secondary verliert das Storage-Netz

Ein Netzausfall braucht einen sicheren Rückweg. Ein eigener Dienst schaltet ens19 ab und nach 60 Sekunden wieder an; networkd setzt die Adresse dann von selbst (Tag 0):

# auf k0s-w2
sudo systemd-run --unit=netzweg bash -c \
  'ip link set ens19 down; sleep 60; ip link set ens19 up'

Nach 15 Sekunden:

# auf k0s-ctrl
ssh k0s-w1 'sudo drbdadm status qtest'
ssh k0s-w2 'sudo drbdadm status qtest | head -2'

Erwartet:

qtest role:Primary
  disk:UpToDate open:yes
  k0s-ctrl role:Secondary
    peer-disk:Diskless peer-client:yes
  k0s-w2 connection:Connecting
qtest role:Secondary
  disk:Outdated open:no

Der Primary hat mit der Witness zwei von drei Stimmen und schreibt weiter. k0s-w2 weiß, dass seine Kopie veraltet ist (Outdated), und kann so nicht Primary werden. Nach der Rückkehr gleicht DRBD die Lücke von selbst ab. Jetzt die Schreibpausen:

# auf k0s-ctrl
ssh k0s-w1 'cat /mnt/qtest/log' | awk 'NR>1 { split(p, a, ":"); split($0, b, ":");
  d = (b[2]*60 + b[3]) - (a[2]*60 + a[3]); if (d > 2.5) print "Lücke", p, "->", $0 }
  { p = $0 }'

Erwartet:

Lücke 02:05:54.830 -> 02:06:05.600

Fällt ein Partner weg, frieren die Schreibzugriffe gut 10 Sekunden ein: DRBD bestätigt einen Schreibvorgang erst, wenn der Partner ihn hat. Ist die Verbindung still, merkt DRBD den Ausfall erst am ausbleibenden Keep-alive: ping-int (10 s) plus ping-timeout (0,5 s); wartet es auf eine Antwort, greift timeout (6 s). Das trifft jede Ressource mit einer Kopie auf dem Node – auch die Datenbank:

# auf k0s-ctrl
kubectl -n demo logs deploy/pg-client --since=10m | grep -B1 -A1 FEHLER | head -4

Erwartet:

02:05:53 ok
02:05:57 FEHLER
02:06:01 FEHLER
02:06:05 ok

pg-0 läuft auf k0s-w3, seine zweite Kopie liegt auf k0s-w2 – zehn Sekunden ohne Commit. Wer über „kurze Hänger bei Netzproblemen“ klagt, sieht genau das.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Versuch B – der Primary verliert das Storage-Netz

Warte, bis netzweg nach 60 Sekunden abgelaufen ist und drbdadm status qtest auf k0s-w1 für k0s-w2 wieder peer-disk:UpToDate zeigt – eine Outdated-Kopie wird nicht Primary. Dann zieh den Schreiber auf k0s-w2 um, damit es den Primary trifft:

# auf k0s-w1
sudo systemctl stop schreiber
sudo umount /mnt/qtest
# auf k0s-w2
sudo mkdir -p /mnt/qtest
sudo mount /dev/drbd/by-res/qtest/0 /mnt/qtest
sudo systemd-run --unit=schreiber bash -c 'while true; do
  date +%T.%N | cut -c1-12 >> /mnt/qtest/log; sync /mnt/qtest/log; sleep 1; done'
sudo systemd-run --unit=netzweg bash -c \
  'ip link set ens19 down; sleep 60; ip link set ens19 up'

Nach 15 Sekunden aus allen drei Blickwinkeln:

# auf k0s-ctrl
ssh k0s-w2 'sudo drbdadm status qtest'
ssh k0s-w1 'sudo drbdadm status qtest | head -2'
sudo drbdadm status qtest

Erwartet:

qtest role:Primary
  disk:UpToDate open:yes
  k0s-ctrl role:Secondary
    peer-disk:Diskless peer-client:yes
  k0s-w1 connection:Connecting
qtest role:Secondary
  disk:Outdated open:no
qtest role:Secondary
  disk:Diskless client:yes open:no
  k0s-w1 role:Secondary
    peer-disk:Outdated
  k0s-w2 role:Primary
    peer-disk:UpToDate

Rechnerisch hätten beide Seiten zwei Stimmen – jede sieht sich und die Witness. Die Witness ist aber mit beiden verbunden und weiß, wer Primary ist; gegen ihn bildet k0s-w1 keine Mehrheit. Kein Split-Brain, wieder etwa 11 Sekunden Pause (02:07:35 -> 02:07:46). Das ist der wahrscheinlichste Fehler in dieser Architektur: Das Storage-Netz hat ein Problem, das Management-Netz nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Versuch C – der Primary verliert alles

Warte wieder, bis netzweg abgelaufen ist und k0s-w1 UpToDate meldet. Jetzt wird k0s-w2 komplett isoliert: keine DRBD-Verbindung mehr, auch nicht zur Witness. Wie in Tag 6 sperrt eine Firewall alle DRBD-Ports, in beide Richtungen, für 90 Sekunden:

# auf k0s-w2
sudo systemd-run --unit=isoliert bash -c '
  iptables -I INPUT -p tcp -m multiport --ports 7000:7999 -j DROP
  iptables -I OUTPUT -p tcp -m multiport --ports 7000:7999 -j DROP
  sleep 90
  iptables -D INPUT -p tcp -m multiport --ports 7000:7999 -j DROP
  iptables -D OUTPUT -p tcp -m multiport --ports 7000:7999 -j DROP'
sleep 25
sudo drbdsetup status qtest --verbose | head -4

Erwartet:

qtest node-id:1 role:Primary suspended:quorum force-io-failures:no
  volume:0 minor:1002 disk:UpToDate
      backing_dev:/dev/mapper/linstor_writecache_qtest_00000 quorum:no open:yes
      blocked:upper

quorum:no, suspended:quorum, blocked:upper: DRBD hält alle Schreibvorgänge an. Auch ein tail auf das Dateisystem kann jetzt hängen bleiben.

Tipp: --ports mit -m multiport passt auf Quell- oder Zielport. Eine Regel nur mit --dport reicht nicht: Eine DRBD-Verbindung, die die Gegenseite aufgebaut hat, läuft auf deiner Seite über einen zufälligen Port. Im Labor blieb so die Verbindung zur Witness halb offen, und der Versuch zeigte Unsinn.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Versuch D – die andere Seite übernimmt

Noch während der Isolation benutzt jemand die andere Seite – genau das tut Kubernetes, wenn es einen Pod nach einem Out-of-Service-Taint woanders startet (Tag 10). k0s-w1 hat mit der Witness die Mehrheit:

# auf k0s-w1
sudo mount /dev/drbd/by-res/qtest/0 /mnt/qtest
tail -1 /mnt/qtest/log
echo "w1 hat übernommen $(date +%T)" | sudo tee -a /mnt/qtest/log
sudo umount /mnt/qtest

Erwartet:

02:11:18.316
w1 hat übernommen 02:11:55

Nach Ablauf der 90 Sekunden kommt k0s-w2 zurück, mit veraltetem Stand und angehaltenen Schreibvorgängen:

# auf k0s-w2
sudo drbdsetup status qtest --verbose | head -3
tail -2 /mnt/qtest/log

Erwartet:

qtest node-id:1 role:Secondary suspended:no force-io-failures:yes
  volume:0 minor:1002 disk:UpToDate
      backing_dev:/dev/mapper/linstor_writecache_qtest_00000 quorum:yes open:yes
tail: cannot open '/mnt/qtest/log' for reading: Input/output error

force-secondary hat gegriffen: DRBD hat den alten Primary abgesetzt, seinen Stand von k0s-w1 überschrieben und lässt jeden Zugriff des alten Dateisystems scheitern. Die Anwendung dort bekommt I/O-Fehler statt veralteter Daten. Aufräumen auf dem alten Primary:

# auf k0s-w2
sudo systemctl stop schreiber
sudo umount /mnt/qtest
sudo drbdadm status qtest | head -2

Erwartet:

qtest role:Secondary
  disk:UpToDate open:no

Was gilt jetzt?

# auf k0s-w1
sudo mount -o ro /dev/drbd/by-res/qtest/0 /mnt/qtest
tail -2 /mnt/qtest/log
sudo umount /mnt/qtest

Erwartet:

02:11:18.316
w1 hat übernommen 02:11:55

Alles bis zur Isolation, dann der Eintrag von k0s-w1. Was k0s-w2 während der Isolation schreiben wollte, ist nie angekommen. Kein Split-Brain – solange es eine dritte Stimme gibt.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Versuch E – ein echtes Split-Brain

Um zu sehen, wie ein Split-Brain aussieht, bekommt eine Ressource bewusst kein Quorum:

# auf k0s-ctrl
linstor resource-definition create sbtest --resource-group rg-k8s
linstor volume-definition create sbtest 200M
linstor resource create sbtest --auto-place 2
linstor resource-definition drbd-options --quorum off sbtest
linstor --no-utf8 --no-color resource list -r sbtest

Erwartet (gekürzt):

    Tie breaker marked for deletion
...
| sbtest       | k0s-w1 | DRBD,WRITECACHE,STORAGE | Unused | Ok    | UpToDate | Yes  |
| sbtest       | k0s-w2 | DRBD,WRITECACHE,STORAGE | Unused | Ok    | UpToDate | Yes  |

Ohne Quorum ist der Tiebreaker nutzlos, LINSTOR räumt ihn weg. Grundzustand anlegen, dann k0s-w2 für 60 Sekunden trennen:

# auf k0s-w1
sudo mkfs.ext4 -q /dev/drbd/by-res/sbtest/0
sudo mkdir -p /mnt/sb
sudo mount /dev/drbd/by-res/sbtest/0 /mnt/sb
echo basis | sudo tee /mnt/sb/datei
sudo umount /mnt/sb
# auf k0s-w2
sudo systemd-run --unit=sbtrennung bash -c '
  iptables -I INPUT -p tcp -m multiport --ports 7000:7999 -j DROP
  iptables -I OUTPUT -p tcp -m multiport --ports 7000:7999 -j DROP
  sleep 60
  iptables -D INPUT -p tcp -m multiport --ports 7000:7999 -j DROP
  iptables -D OUTPUT -p tcp -m multiport --ports 7000:7999 -j DROP'

Nach 20 Sekunden schreibst du auf beiden Seiten – ohne Quorum wird jede beim Mounten Primary:

# auf k0s-w2
sudo mkdir -p /mnt/sb
sudo mount /dev/drbd/by-res/sbtest/0 /mnt/sb
echo "seite k0s-w2" | sudo tee -a /mnt/sb/datei
sudo umount /mnt/sb

Wiederhole das auf k0s-w1 mit seite k0s-w1. Eine Minute später:

# auf k0s-ctrl
ssh k0s-w1 'sudo drbdadm status sbtest'
ssh k0s-w1 "sudo journalctl -k --since -3min | grep 'Split-Brain detected' | cut -c1-88"
linstor --no-utf8 --no-color resource list -r sbtest | cut -c44-100

Erwartet:

sbtest role:Secondary
  disk:UpToDate open:no
  k0s-w2 connection:StandAlone
Nov 20 02:15:02 k0s-w1 kernel: drbd sbtest/0 drbd1003 k0s-w2: Split-Brain detected but u
-------------------------------------------------------
| Layers                  | Usage  | Conns              |
=======================================================
| DRBD,WRITECACHE,STORAGE | Unused | StandAlone(k0s-w2) |
| DRBD,WRITECACHE,STORAGE | Unused | StandAlone(k0s-w1) |

Beide Seiten sind UpToDate, und jede hat für sich recht. DRBD kann nicht entscheiden, welche Änderungen zählen, und trennt dauerhaft: StandAlone heißt, es wird nicht mehr versucht. Die Meldung endet mit unresolved, dropping connection!.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Das Split-Brain auflösen

Beim Auflösen verwirft eine Seite alle Änderungen seit der Trennung. Erst nachsehen, dann entscheiden – auf beiden Nodes nur lesend:

# auf k0s-w1
sudo mount -o ro /dev/drbd/by-res/sbtest/0 /mnt/sb
cat /mnt/sb/datei
sudo umount /mnt/sb

Erwartet:

basis
seite k0s-w1

Auf k0s-w2 steht basis und seite k0s-w2. k0s-w1 gewinnt. Auf der Verliererseite:

Achtung: --discard-my-data verwirft unwiderruflich alle Änderungen dieses Nodes seit der Trennung. Er gehört immer auf den Node, dessen Daten weg sollen – lies den Hostnamen im Prompt, bevor du Enter drückst. Im Zweifel vorher die Daten der Verliererseite sichern.

# auf k0s-w2
sudo drbdadm disconnect sbtest
sudo drbdadm secondary sbtest
sudo drbdadm connect --discard-my-data sbtest

Die Gewinnerseite verbindet aus StandAlone nicht von selbst:

# auf k0s-w1
sudo drbdadm connect sbtest
sudo drbdadm status sbtest

Erwartet:

sbtest role:Secondary
  disk:UpToDate open:no
  k0s-w2 role:Secondary
    peer-disk:UpToDate
# auf k0s-w2
sudo journalctl -k --since -1min | grep resync-finished | cut -c1-88
sudo mount -o ro /dev/drbd/by-res/sbtest/0 /mnt/sb
cat /mnt/sb/datei
sudo umount /mnt/sb

Erwartet:

Nov 20 02:15:45 k0s-w2 kernel: drbd sbtest/0 drbd1003 k0s-w1: repl( SyncTarget -> Establ
basis
seite k0s-w1

seite k0s-w2 ist weg, wie beabsichtigt. DRBD hat nur die geänderten Blöcke übertragen.

Fall Verhalten Schreibpause
Secondary verliert Storage-Netz Primary schreibt weiter, Resync von selbst ca. 10 s
Primary verliert Storage-Netz Witness entscheidet, kein Split-Brain ca. 10 s
Primary komplett isoliert suspended:quorum so lange wie der Ausfall
Gegenseite übernimmt alter Primary abgesetzt, I/O-Fehler –
ohne Quorum getrennt beschrieben Split-Brain, StandAlone keine, Datenverlust

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig, ob k0s-w1 für qtest gerade Quorum hat. Zeitziel: 20 s
  2. Zeig die wirksamen Quorum-Einstellungen von qtest auf k0s-w1. Zeitziel: 30 s
  3. Zähl die StandAlone-Verbindungen im ganzen Cluster. Zeitziel: 15 s
  4. Zähl die Split-Brain-Meldungen der letzten Stunde auf k0s-w2. Zeitziel: 20 s

Lösung

# auf k0s-ctrl
ssh k0s-w1 'sudo drbdsetup status qtest --verbose | grep -o "quorum:[a-z]*"'
ssh k0s-w1 'sudo drbdsetup show qtest | grep -E "quorum|on-suspended"'
linstor --no-utf8 --no-color resource list | grep -c StandAlone
ssh k0s-w2 'sudo journalctl -k --since -1h | grep -c "Split-Brain detected"'

Erwartet (gekürzt):

quorum:yes
        quorum              majority;
        on-suspended-primary-outdated   force-secondary;
0
2

on-no-quorum fehlt, weil suspend-io der Standard ist (Tag 9). Die Meldung steht je Seite zweimal im Log.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf k0s-ctrl
linstor --no-utf8 --no-color resource list --faulty

Erwartet: eine leere Tabelle.

# auf k0s-ctrl
ssh k0s-w2 'sudo iptables -S | grep -c 7000:7999'

Erwartet: 0 – alle Firewall-Regeln sind wieder weg.

# auf k0s-ctrl
linstor --no-utf8 --no-color resource list | grep -c StandAlone

Erwartet: 0.

Challenge

Schalte das Quorum für sbtest wieder ein und wiederhole Versuch E. Was passiert beim Mounten auf der getrennten Seite, und was steht danach auf beiden Kopien?

Hinweis: drbd-options kennt zu jeder Option ein --unset-….

Lösung

# auf k0s-ctrl
linstor resource-definition drbd-options --unset-quorum sbtest
linstor --no-utf8 --no-color resource-definition list-properties sbtest | grep quorum

Erwartet (gekürzt):

    Tie breaker resource 'sbtest' created on k0s-ctrl
...
| DrbdOptions/Resource/quorum | majority  |

LINSTOR setzt majority von selbst wieder an der Ressource – wie an jeder Ressource mit drei Stimmen, auch an data-pg-0 –, und der Tiebreaker kommt zurück. Trenne k0s-w2 wie in Drill 6 (Unit-Name sbtrennung2) und versuche nach 20 Sekunden:

# auf k0s-w2
sudo mount /dev/drbd/by-res/sbtest/0 /mnt/sb
sudo drbdadm status sbtest | head -2

Erwartet:

mount: /mnt/sb: mount(2) system call failed: No data available.
       dmesg(1) may have more information after failed mount system call.
sbtest role:Secondary suspended:quorum
  disk:UpToDate quorum:no open:no blocked:upper

Die Minderheit darf nicht Primary werden, der Mount scheitert. k0s-w1 mountet und schreibt (seite w1, runde 2). Nach der Trennung steht auf k0s-w2 ohne jeden Handgriff basis, seite k0s-w1, seite w1, runde 2 – kein Split-Brain.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf k0s-ctrl
linstor resource-definition delete qtest
linstor resource-definition delete sbtest

Die Einhängepunkte /mnt/qtest und /mnt/sb auf k0s-w1 und k0s-w2 sind leer und dürfen bleiben.

Interview-Notiz

  • Wie verhindert DRBD Split-Brain? Mit Quorum: Nur wer die Mehrheit der Stimmen sieht, darf schreiben. Die dritte Stimme ist eine diskless Witness an einem dritten Ort.
  • Warum hängen Datenbanken kurz, wenn ein Storage-Node wegfällt? DRBD bestätigt einen Schreibvorgang erst, wenn der Partner ihn hat, und erkennt den Ausfall erst am ausbleibenden Keep-alive (ping-int plus ping-timeout) – rund 10 Sekunden.
  • Wie löst man ein Split-Brain auf? Beide Seiten lesend prüfen, Verlierer wählen, dort disconnect, secondary, connect --discard-my-data, auf dem Gewinner connect.

Enterprise-Notiz

  • Die Witness gehört in einen dritten Brandabschnitt oder Standort, mit eigenem Netzweg zu beiden Zonen – sonst ist sie im Ernstfall mit einer Seite weg.
  • Redundantes Storage-Netz: Bonding fängt den Ausfall einer Leitung ab, bevor DRBD ihn bemerkt. Mit zwei DRBD-Pfaden nutzt der TCP-Transport nur einen und baut die Verbindung erst nach erkanntem Ausfall über den nächsten neu auf – die Erkennungszeit bleibt. Die 10 Sekunden lassen sich mit ping-int/ping-timeout/timeout verkleinern, aber nicht ohne Fehlalarme abschaffen.
  • quorum off gehört nie in Produktion. Ressourcen ohne Quorum per Monitoring melden.
  • StandAlone und suspended:quorum auf dem Primary alarmieren (Tag 18) – beides heilt nicht von selbst bzw. hält eine Anwendung an.
  • Split-Brain-Auflösung ist ein Vier-Augen-Vorgang mit vorheriger Sicherung der Verliererseite.