Clusteropslag voor kleine webclusters op basis van drbd+ocfs2

Waar we het over zullen hebben:
Hoe u snel gedeelde opslag voor twee servers kunt implementeren op basis van drbd+ocfs2-oplossingen.

Voor wie het nuttig zal zijn:
De tutorial zal nuttig zijn voor systeembeheerders en iedereen die een opslagimplementatiemethode kiest of de oplossing wil proberen.

Welke beslissingen hebben we afgewezen en waarom?

Vaak worden we geconfronteerd met een situatie waarin we gedeelde opslag met goede lees-schrijfprestaties moeten implementeren op een klein webcluster. We hebben verschillende opties geprobeerd om gedeelde opslag voor onze projecten te implementeren, maar slechts weinigen konden ons op meerdere indicatoren tegelijk tevreden stellen. Nu zullen we je vertellen waarom.

• Glusterfs stelde ons niet tevreden met de lees- en schrijfprestaties, er waren problemen met het gelijktijdig lezen van een groot aantal bestanden en er was een hoge belasting van de CPU. Het probleem met het lezen van bestanden zou kunnen worden opgelost door ze rechtstreeks vanuit Brick te openen, maar dit is niet altijd van toepassing en is over het algemeen onjuist.

• Ceph hield niet van de buitensporige complexiteit, die schadelijk kan zijn bij projecten met 2-4 servers, vooral als het project vervolgens wordt onderhouden. Nogmaals, er zijn ernstige prestatiebeperkingen die ons dwingen afzonderlijke opslagclusters te bouwen, zoals bij glusterfs.

• Het gebruik van één NFS-server om gedeelde opslag te implementeren roept vragen op in termen van fouttolerantie.

• s3 is een uitstekende populaire oplossing voor een bepaald scala aan taken, maar het is geen bestandssysteem, wat de reikwijdte ervan beperkt.

• lsync. Als we al zijn begonnen te praten over ‘niet-bestandssystemen’, dan is het de moeite waard om deze populaire oplossing te bespreken. Niet alleen is het niet geschikt voor tweerichtingsverkeer (maar als je het echt wilt, dan kan dat ook), het werkt ook niet stabiel op een groot aantal bestanden. Een leuke toevoeging aan het geheel is dat het single-threaded is. De reden ligt in de architectuur van het programma: het gebruikt inotify om werkobjecten te monitoren, die het toewijst bij het opstarten en tijdens het opnieuw scannen. rsync wordt gebruikt als overdrachtsmedium.

Tutorial: hoe u gedeelde opslag implementeert op basis van drbd+ocfs2

Eén van de handigste oplossingen voor ons was de koppeling ocfs2+drbd. Nu zullen we u vertellen hoe u snel gedeelde opslag voor twee servers kunt implementeren op basis van een oplossingsdatabase. Maar eerst iets over de componenten:

DRBD - een opslagsysteem uit de standaard Linux-distributie waarmee je gegevens in blokken tussen servers kunt repliceren. De belangrijkste toepassing is het bouwen van fouttolerante opslag.

OCFS2 - een bestandssysteem dat gedeeld gebruik van dezelfde opslag door meerdere systemen mogelijk maakt. Inbegrepen in de Linux-distributie en is een kernelmodule en gebruikersruimtehulpmiddelen voor het werken met de FS. OCFS2 kan niet alleen via DRBD worden gebruikt, maar ook via iSCSI met meerdere verbindingen. In ons voorbeeld gebruiken we DRBD.

Alle acties worden uitgevoerd op ubuntu-server 18.04 in een minimale configuratie.

Stap 1. DRBD configureren:

In het bestand /etc/drbd.d/drbd0.res beschrijven we ons virtuele blokapparaat /dev/drbd0:

resource drbd0 {
    syncer { rate 1000M; }
    net {
        allow-two-primaries;
        after-sb-0pri discard-zero-changes;
        after-sb-1pri discard-secondary;
        after-sb-2pri disconnect;
    }
    startup { become-primary-on both; }
    on drbd1 {
        meta-disk internal;
        device /dev/drbd0;
        disk /dev/vdb1;
        address 10.10.10.192:7789;
}
    on drbd2 {
        meta-disk internal;
        device /dev/drbd0;
        disk /dev/vdb1;
        address 10.10.10.193:7789;
}
}

metaschijf intern — gebruik dezelfde blokapparaten om metagegevens op te slaan
apparaat /dev/drbd0 — gebruik /dev/drbd0 als pad naar het drbd-volume.
schijf /dev/vdb1 - gebruik /dev/vdb1
synchronisatie {snelheid 1000M; } — gebruik gigabit-kanaalbandbreedte
allow-twee-primaires - een belangrijke optie waarmee wijzigingen op twee primaire servers kunnen worden geaccepteerd
na-sb-0pri, na-sb-1pri, na-sb-2pri — opties die verantwoordelijk zijn voor de acties van het knooppunt wanneer splitbrain wordt gedetecteerd. Meer details vindt u in de documentatie.
wordt-primair-op beide — stelt beide knooppunten in op primair.

In ons geval hebben we twee absoluut identieke VM’s, met een speciaal virtueel netwerk met een doorvoer van 10 gigabit.

In ons voorbeeld zijn de netwerknamen van twee clusterknooppunten drbd1 en drbd2. Voor een goede werking moet u de namen en IP-adressen van hosts in /etc/hosts matchen.

10.10.10.192 drbd1
10.10.10.193 drbd2

Stap 2. Knooppunten instellen:

Op beide servers draaien we:

drbdadm create-md drbd0

modprobe drbd
drbdadm up drbd0
cat /proc/drbd

Wij krijgen het volgende:

U kunt de synchronisatie starten. Op het eerste knooppunt moet u uitvoeren:

drbdadm primary --force drbd0

Laten we eens kijken naar de status:

cat /proc/drbd

Geweldig, de synchronisatie is begonnen. We wachten tot het einde en zien de foto:

Stap 3. Start de synchronisatie op het tweede knooppunt:

drbdadm primary --force drbd0

Wij krijgen het volgende:

Nu kunnen we vanaf twee servers naar drbd schrijven.

Stap 4. Installeer en configureer ocfs2.

We zullen een vrij triviale configuratie gebruiken:

cluster:
     node_count = 2
     name = ocfs2cluster

node:
     number = 1
     cluster = ocfs2cluster
     ip_port = 7777
     ip_address = 10.10.10.192
     name = drbd1

node:
     number = 2
     cluster = ocfs2cluster
     ip_port = 7777
     ip_address = 10.10.10.193
     name = drbd2

Het moet erin worden opgeschreven /etc/ocfs2/cluster.conf op beide knooppunten.

We maken een FS op drbd0 op elk knooppunt:

mkfs.ocfs2 -L "testVol" /dev/drbd0

Hier hebben we een bestandssysteem gemaakt met het label testVol op drbd0, met behulp van de standaardparameters.

In /etc/default/o2cb moet je instellen (zoals in ons configuratiebestand)

O2CB_ENABLED=true 
O2CB_BOOTCLUSTER=ocfs2cluster 

en voer op elk knooppunt uit:

o2cb register-cluster ocfs2cluster

Vervolgens schakelen we in en voegen we alle eenheden toe die we nodig hebben voor autorun:

systemctl enable drbd o2cb ocfs2
systemctl start drbd o2cb ocfs2

Een deel hiervan zal al actief zijn tijdens het installatieproces.

Stap 5. Voeg koppelpunten toe aan fstab op beide knooppunten:

/dev/drbd0 /media/shared ocfs2 defaults,noauto,heartbeat=local 0 0

Directory /media/gedeeld het moet van tevoren worden gemaakt.

Hier gebruiken we de noauto-opties, wat betekent dat het bestand niet wordt aangekoppeld bij het opstarten (ik geef er de voorkeur aan netwerkbestanden te koppelen via systemd) en heartbeat=local, wat betekent dat de heartbeat-service op elk knooppunt wordt gebruikt. Er is ook een mondiale hartslag, die meer geschikt is voor grote clusters.

Vervolgens kunt u monteren /media/gedeeld en controleer de inhoudsynchronisatie.

Klaar! Als gevolg hiervan krijgen we min of meer fouttolerante opslag met schaalbaarheid en behoorlijke prestaties.

Bron: www.habr.com