🥇LINSTOR-lager og dets integration med OpenNebula

For ikke så længe siden præsenterede folkene fra LINBIT deres nye SDS-løsning — Linstor. Det er et helt frit lagersystem, der bygger på velprøvede teknologier: DRBD, LVM, ZFS. Linstor kombinerer enkelhed med en veludviklet arkitektur, hvilket muliggør stabilitet og imponerende resultater.

I dag vil jeg gerne tale lidt mere om det og vise, hvor nemt det kan integreres med OpenNebula ved at bruge linstor_un — en ny driver, jeg har udviklet specielt til dette formål.

Linstor i kombination med OpenNebula gør det muligt at bygge en hurtig og pålidelig sky, der uden problemer kan implementeres på ens egen infrastruktur.

Linstor-arkitektur

Linstor er hverken et filsystem eller et bloklager i sig selv; Linstor er en orkestrator, der tilbyder et abstractionslag til at automatisere oprettelsen af volumener i LVM eller ZFS og replikere dem ved hjælp af DRBD9.

Bryder med stereotype opfattelser

Men vent, DRBD? — Hvorfor automatisere det, og hvordan kan det overhovedet fungere?

Lad os huske fortiden, da DRBD8 var meget populært. Dens standardbrug involverede at oprette ét stort blokdevice og dele det op i mange små stykker ved hjælp af LVM. Et slags mdadm RAID-1 men med netværksreplikation.

Denne tilgang er ikke uden ulemper, og derfor blev principperne for opbygning af lagersystemer ændret med ankomsten af DRBD9, hvor der nu oprettes hver sit DRBD-device til hver virtuel maskine.

Tilgang med uafhængige blok-enheder muliggør bedre udnyttelse af plads i klyngen samt tilføjer en række yderligere muligheder. For eksempel kan der defineres antal replikater for hver sådan enhed, deres placering og individuelle indstillinger. De er lette at oprette / slette, tage snapshots af, ændre størrelse, aktivere kryptering og meget mere. Det er værd at bemærke, at DRBD9 også understøtter kvorum, hvilket kan forhindre split-brain-situationer.

Ressourcer og backends

Når der oprettes et nyt blokdevice, placerer Linstor det nødvendige antal replikater på forskellige noder i klyngen. Hver sådan replikat kalder vi en DRBD-ressource.

Ressourcer findes i to typer:

Data-ressource — repræsenterer et DRBD-device placeret på en node i LVM eller ZFS-puljen.
I øjeblikket er der støtte til flere backend-systemer, og antallet vokser konstant. Der er support for LVM, ThinLVM og ZFS. Sidstnævnte to tillader oprettelse og brug af snapshots.
Diskless-ressource repræsenterer en DRBD-enhed placeret på en node uden backend, men som gør det muligt at behandle den som en almindelig blok-enhed, alle læse/skrive-operationer vil blive omdirigeret til data-ressourcerne. Den nærmeste analog til diskless-ressourcer er iSCSI LUN.

Hver DRBD-ressource kan have op til 8 replikaer, og kun én af dem kan som standard være aktiv — Primær, alle andre vil være Sekundær og deres anvendelse vil ikke være mulig, så længe der er mindst én Primær, altså vil de blot replikere data imellem sig.

Når en DRBD-enhed monteres i systemet, bliver den automatisk Primær, således kan selv Diskless-ressourcen, i DRBD-terminologi, være Primær.

Hvad er så formålet med Linstor?

Ved at stole på alle ressourcekrævende opgaver til kernen, fungerer Linstor i bund og grund som en almindelig Java-applikation, der gør det muligt at automatisere oprettelsen af DRBD-ressourcer uden besvær.
Hver ressource, der oprettes af det, vil være en uafhængig DRBD-klynge, som fungerer selvstændigt, uanset tilstanden af control-plane og de øvrige DRBD-ressourcer.

Linstor består kun af to komponenter:

Linstor-controller — Hovedcontrolleren, som tilbyder et API til oprettelse og administration af ressourcer. Den kommunikerer også med satellitterne, kontrollerer deres ledige plads og sender opgaver for at oprette og slette nye ressourcer. Den kører i en enkelt instans og bruger en database, som kan være enten intern (H2) eller ekstern (PostgreSQL, MySQL, MariaDB)
Linstor-satellite — Installeres på alle storage-noder og giver controlleren information om den ledige plads, samt udfører opgaver modtaget fra controlleren for at oprette og slette nye volumener og DRBD-enheder oven på dem.

Linstor arbejder med følgende nøglebegreber:

Node — en fysisk server, hvor DRBD-ressourcerne vil blive oprettet og anvendt.
Storage Pool — en LVM eller ZFS-pool, der er oprettet på noden, hvor DRBD-ressourcerne vil blive placeret. Der er også mulighed for en diskless-pool — en pool, hvor der kun vil blive placeret diskless-ressourcer.
Ressource Definition — Definition af ressourcen, i sin essens er det en prototype, der beskriver navnet og alle dets egenskaber.
Volumen Definition — Definition af volumen. Hver ressource kan bestå af flere volumener, og hver volumen skal have en størrelse.
Ressource — En oprettet instans af en blokdevice, hver ressource skal placeres på en bestemt node og i en eller anden storage pool.

Installation af Linstor

Jeg anbefaler at bruge Ubuntu som system, da der findes en færdig PPA:

add-apt-repository ppa:linbit/linbit-drbd9-stack
apt-get update

Eller Debian, hvor Linstor kan installeres fra det officielle repository til Proxmox:

wget -O- https://packages.linbit.com/package-signing-pubkey.asc | apt-key add -
PVERS=5 && echo "deb http://packages.linbit.com/proxmox/ proxmox-$PVERS drbd-9.0" > 
    /etc/apt/sources.list.d/linbit.list
apt-get update

Controller

Her er det simpelt:

apt-get install linstor-controller linstor-client
systemctl enable linstor-controller
systemctl start linstor-controller

Storage-noder

I øjeblikket leveres in-tree kerne-modulet i Linux DRBD8, desværre er det ikke passende for os, og vi skal installere DRBD9:

apt-get install drbd-dkms

Erfaringen viser, at de fleste problemer opstår, fordi systemet har indlæst DRBD8-modulet i stedet for DRBD9. Heldigvis kan dette nemt kontrolleres ved at udføre:

modprobe drbd
cat /proc/drbd

Hvis du ser version: 9 — så er alt i orden, hvis version: 8 — så er der noget galt, og du skal tage yderligere skridt for at finde årsagerne.

Nu skal vi installere linstor-satellite og drbd-utils:

apt-get install linstor-satellite drbd-utils
systemctl enable linstor-satellite
systemctl start linstor-satellite

Oprettelse af klynge

Storage pools og noder

Som backend vil vi bruge ThinLVM, da det er den mest enkle og understøtter snapshots.
Installer lvm2, hvis du ikke allerede har gjort det, lad os oprette en ThinLVM-pool på alle vores storage-noder:

sudo vgcreate drbdpool /dev/sdb
sudo lvcreate -L 800G -T drbdpool/thinpool

Alle efterfølgende handlinger kan udføres direkte på controlleren:

Lad os tilføje vores noder:

linstor node create node1 127.0.0.11
linstor node create node2 127.0.0.12
linstor node create node3 127.0.0.13

Lad os oprette storage pools:

linstor storage-pool create lvmthin node1 data drbdpool/thinpool
linstor storage-pool create lvmthin node2 data drbdpool/thinpool
linstor storage-pool create lvmthin node3 data drbdpool/thinpool

Nu skal vi tjekke de oprettede pools:

linstor storage-pool list

Hvis alt er gjort korrekt, bør vi se noget i stil med:

+-------------------------------------------------------------------------------------------------------+
| StoragePool | Node  | Driver   | PoolName          | FreeCapacity | TotalCapacity | SupportsSnapshots |
|-------------------------------------------------------------------------------------------------------|
| data        | node1 | LVM_THIN | drbdpool/thinpool |       64 GiB |        64 GiB | true              |
| data        | node2 | LVM_THIN | drbdpool/thinpool |       64 GiB |        64 GiB | true              |
| data        | node3 | LVM_THIN | drbdpool/thinpool |       64 GiB |        64 GiB | true              |
+-------------------------------------------------------------------------------------------------------+

DRBD-ressourcer

Lad os nu prøve at oprette vores nye DRBD-ressource:

linstor resource-definition create myres
linstor volume-definition create myres 1G
linstor resource create myres --auto-place 2

Lad os tjekke de oprettede ressourcer:

linstor resource list

+------------------------------------------------------------------------------------------------------+
| Node  | Resource | StoragePool | VolumeNr | MinorNr | DeviceName    | Allocated  | InUse  |    State |
|------------------------------------------------------------------------------------------------------|
| node1 | myres    | data        | 0        | 1084    | /dev/drbd1084 | 52 KiB     | Unused | UpToDate |
| node2 | myres    | data        | 0        | 1084    | /dev/drbd1084 | 52 KiB     | Unused | UpToDate |
+------------------------------------------------------------------------------------------------------+

Fint! — vi kan se, at ressourcen er blevet oprettet på de første to noder, vi kan også prøve at oprette en diskless-ressource på den tredje:

linstor resource create --diskless node3 myres

På noderne finder du altid denne enhed som /dev/drbd1084 eller /dev/drbd/by-res/myres/0

Sådan fungerer Linstor, du kan få mere information fra den officielle dokumentation.

Nu vil jeg fortælle om, hvordan man integrerer det med OpenNebula

Konfiguration af OpenNebula

Jeg vil ikke gå for meget i dybden med konfigurationsprocessen for OpenNebula, da alle trin er grundigt beskrevet i den officielle dokumentation, som jeg anbefaler dig at konsultere, jeg vil kun fortælle om integrationen af OpenNebula med Linstor.

linstor_un

For at løse denne opgave har jeg skrevet en egen driver — linstor_un, som i øjeblikket er tilgængelig som en plugin og skal installeres separat.

Hele installationen foregår på frontend OpenNebula-noderne og kræver ikke yderligere handlinger på compute-noderne.

Først skal vi sikre os, at vi har jq og linstor-client:

apt-get install jq linstor-client

Kommandoen linstor node list bør vise listen over noder. Alle compute-noder i OpenNebula skal være tilføjet til Linstor-klyngen.

Lad os downloade og installere pluginet:

curl -L https://github.com/OpenNebula/addon-linstor_un/archive/master.tar.gz | tar -xzvf - -C /tmp

mv /tmp/addon-linstor_un-master/vmm/kvm/* /var/lib/one/remotes/vmm/kvm/

mkdir -p /var/lib/one/remotes/etc/datastore/linstor_un
mv /tmp/addon-linstor_un-master/datastore/linstor_un/linstor_un.conf /var/lib/one/remotes/etc/datastore/linstor_un/linstor_un.conf

mv /tmp/addon-linstor_un-master/datastore/linstor_un /var/lib/one/remotes/datastore/linstor_un
mv /tmp/addon-linstor_un-master/tm/linstor_un /var/lib/one/remotes/tm/linstor_un

rm -rf /tmp/addon-linstor_un-master

Nu skal vi tilføje det til OpenNebula-konfigurationen ved at udføre de enkle trin beskrevet her.

Efterfølgende genstarter vi OpenNebula:

systemctl restart opennebula

Og vi tilføjer vores datastores, systemet:

cat > system-ds.conf <<EOT
NAME="linstor-system"
TYPE="SYSTEM_DS"
STORAGE_POOL="data"
AUTO_PLACE="2"
CLONE_MODE="snapshot"
CHECKPOINT_AUTO_PLACE="1"
BRIDGE_LIST="node1 node2 node3"
TM_MAD="linstor_un"
EOT

onedatastore create system-ds.conf

Og billedlageret:

cat > images-ds.conf <<EOT
NAME="linstor-images"
TYPE="IMAGE_DS"
STORAGE_POOL="data"
AUTO_PLACE="2"
BRIDGE_LIST="node1 node2 node3"
DISK_TYPE="BLOCK"
DS_MAD="linstor_un"
TM_MAD="linstor_un"
EOT

onedatastore create images-ds.conf

Parameter AUTO_PLACE angiver antallet af data-replikaer, der vil blive oprettet for hver ny billed i OpenNebula.
Parameter CLONE_MODE angiver, hvordan billeder vil blive klonet, når nye virtuelle maskiner oprettes, snapshot — vil oprette et snapshot af billedet og udrulle den virtuelle maskine fra snapshotet, copy — vil lave en fuld kopi af billedet for hver virtuel maskine.
I BRIDGE_LIST det anbefales at angive alle noder, der skal bruges til kloning af billeder.

Den komplette liste over understøttede parametre findes i README projekt.

Med dette er konfigurationen afsluttet, nu kan vi hente en appliance fra den officielle OpenNebula Marketplace og oprette virtuelle maskiner ud fra det.

Link til projektet:
https://github.com/OpenNebula/addon-linstor_un

Kilde: habr.com