Impostare ATA over Ethernet (AoE) su Debian 8 (Inizializzatore e Destinazione)

Questo tutorial ti mostra come impostare un client AoE (inizializzatore) e un server (destinazione) su Debian 8 /Jessie). Il termine AoE sta per “ATA over Ethernet” che è un protocollo di rete di archiviazione (SAN) che consente ai client AoE di utilizzare dispositivi di archiviazione sul server AoE (remoto) tramite una normale rete ethernet. “Remoto” in questo caso significa “all’interno della stessa LAN” perché AoE non è instradabile al di fuori di una LAN (questa è una differenza principale rispetto a iSCSI). Per il client AoE (inizializzatore), l’archiviazione remota appare come un normale disco rigido collegato localmente.

1 Nota Preliminare

Sto usando due server Debian 8 qui:

server1.example.com (Inizializzatore): indirizzo IP 192.168.1.100
server2.example.com (Destinazione): indirizzo IP 192.168.1.101

2 Caricare il Modulo del Kernel AoE su entrambi i sistemi

server1/server2:

Come primo passo, dobbiamo assicurarci che il Kernel sui nostri server supporti ATA Over Ethernet. Esegui il seguente comando come utente root.

grep ATA_OVER /boot/config-`uname -r`

Questo dovrebbe visualizzare qualcosa del genere:

root@server1:/tmp# grep ATA_OVER /boot/config-`uname -r`  
CONFIG_ATA_OVER_ETH=m  
root@server1:/tmp#

Questo significa che AoE è stato costruito come modulo del kernel. Ora verifichiamo se il modulo è caricato:

lsmod | grep aoe

Se non ottieni nulla, significa che non è caricato. In questo caso, possiamo caricarlo come segue:

modprobe aoe

Controlliamo di nuovo se il modulo è caricato:

lsmod | grep aoe

root@server1:/tmp# lsmod | grep aoe  
aoe 51917 0  
root@server1:/tmp#

Per avere il modulo caricato automaticamente all’avvio del sistema, aggiungiamo il modulo aoe a /etc/modules:

nano /etc/modules

# /etc/modules: kernel modules to load at boot time.
#
# This file contains the names of kernel modules that should be loaded
# at boot time, one per line. Lines beginning with "#" are ignored.
# Parameters can be specified after the module name.

aoe

3 Impostare la Destinazione (server2)

server2:

Per prima cosa, impostiamo la destinazione AoE (server2):

apt-get install vblade

Possiamo utilizzare volumi logici non utilizzati, file immagine, dischi rigidi (ad es. /dev/sdb), partizioni di dischi rigidi (ad es. /dev/sdb1) o dispositivi RAID (ad es. /dev/md0) per l’archiviazione. In questo esempio, utilizzerò un file immagine di 20GB che è memorizzato nella cartella /storage.

mkdir /storage  
dd if=/dev/zero of=/storage/storage1.img bs=1024k count=20000

Questo crea il file immagine /storage/storage1.img con una dimensione di 20GB.

Se vuoi utilizzare un volume logico invece, puoi crearne uno con una dimensione di 20GB chiamato storage1 nel gruppo di volumi vg0 in questo modo:

lvcreate -L20G -n storage1 vg0

Ora esportiamo il nostro dispositivo di archiviazione come segue:

vbladed 0 1 eth0 /storage/storage1.img

Il primo numero (0) è il numero dello scaffale (maggiore), il secondo (1) è il numero dello slot (minore), cambia questi numeri a tuo piacimento. Ogni dispositivo AoE è identificato da una coppia maggiore/minore che deve essere unica (se stai esportando più dispositivi), con maggiore tra 0-65535 e minore tra 0-255. La parte eth0 indica a vbladed quale dispositivo ethernet utilizzare (se il tuo dispositivo ethernet è eth1, allora usa eth1 - puoi scoprire i tuoi dispositivi ethernet eseguendo

ifconfig

Per avviare l’esportazione automaticamente ogni volta che avvii la destinazione, apri /etc/rc.local…

nano /etc/rc.local

… e aggiungi la seguente riga (prima della riga exit 0):

[...]  
/usr/sbin/vbladed 0 1 eth0 /storage/storage1.img  
[...]

4 Impostare il Client AoE / Inizializzatore (server1)

server1:

Su server1, installiamo l’inizializzatore:

apt-get install aoetools

Ora verifichiamo quali dispositivi di archiviazione AoE sono disponibili:

aoe-discover

Non preoccuparti, il comando non mostrerà alcun output. Il comando:

aoe-stat

dovrebbe ora mostrare i dispositivi di archiviazione:

root@server1:/tmp# aoe-stat  
e0.1 20.971GB eth0 1024 up  
root@server1:/tmp#

A questo punto abbiamo un nuovo dispositivo a blocchi disponibile sulla macchina client chiamato /dev/etherd/e0.1. Se diamo un’occhiata all’albero /dev, appare un nuovo nodo:

ls -la /dev/etherd/

root@server1:/tmp# ls -la /dev/etherd/  
total 0  
drwxr-xr-x 2 root root 160 Mar 22 08:46 .  
drwxr-xr-x 19 root root 3160 Mar 22 08:34 ..  
c-w--w---- 1 root disk 152, 3 Mar 22 08:34 discover  
brw-rw---- 1 root disk 152, 0 Mar 22 08:46 e0.1  
cr--r----- 1 root disk 152, 2 Mar 22 08:34 err  
c-w--w---- 1 root disk 152, 6 Mar 22 08:34 flush  
c-w--w---- 1 root disk 152, 4 Mar 22 08:34 interfaces  
c-w--w---- 1 root disk 152, 5 Mar 22 08:34 revalidate  
root@server1:/tmp#

Per utilizzare quel dispositivo /dev/etherd/e0.1, dobbiamo formattarlo:

fdisk /dev/etherd/e0.1

root@server1:/tmp# fdisk /dev/etherd/e0.1

Benvenuto in fdisk (util-linux 2.25.2).  
Le modifiche rimarranno in memoria solo fino a quando non decidi di scriverle.  
Fai attenzione prima di utilizzare il comando di scrittura.

Il dispositivo non contiene una tabella delle partizioni riconosciuta.  
Creata una nuova etichetta del disco DOS con identificatore del disco 0x2922f0be.

Comando (m per aiuto): <-- n  
Tipo di partizione  
p primaria (0 primaria, 0 estesa, 4 libere)  
e estesa (contenitore per partizioni logiche)  
Seleziona (predefinito p): <-- p  
Numero di partizione (1-4, predefinito 1): <-- 1  
Primo settore (2048-40959999, predefinito 2048): <-- ENTER  
Ultimo settore, +settori o +dimensione{K,M,G,T,P} (2048-40959999, predefinito 40959999): <-- ENTER

Creata una nuova partizione 1 di tipo 'Linux' e di dimensione 19.5 GiB.

Comando (m per aiuto): <-- w

La tabella delle partizioni è stata modificata.  
Chiamando ioctl() per rileggere la tabella delle partizioni.  
Sincronizzazione dischi.

Ora creiamo un filesystem su /dev/etherd/e0.1p1…

mkfs.ext4 /dev/etherd/e0.1p1

root@server1:/tmp# mkfs.ext4 /dev/etherd/e0.1p1  
mke2fs 1.42.12 (29-Aug-2014)  
Creazione filesystem con 5119744 4k blocchi e 1281120 inodes  
UUID del filesystem: 2342cd83-bd45-4975-96c0-b0f366b73778  
Backup del superblocco memorizzati sui blocchi:  
 32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,  
 4096000

Allocazione delle tabelle di gruppo: fatto  
Scrittura delle tabelle degli inode: fatto  
Creazione del journal (32768 blocchi): fatto  
Scrittura dei superblocco e informazioni di contabilizzazione del filesystem: fatto

… e montiamolo per scopi di test:

mount /dev/etherd/e0.1p1 /mnt

Dovresti ora vedere il nuovo dispositivo negli output di…

mount

root@server1:/tmp# mount  
sysfs on /sys type sysfs (rw,nosuid,nodev,noexec,relatime)  
proc on /proc type proc (rw,nosuid,nodev,noexec,relatime)  
udev on /dev type devtmpfs (rw,relatime,size=10240k,nr_inodes=125556,mode=755)  
devpts on /dev/pts type devpts (rw,nosuid,noexec,relatime,gid=5,mode=620,ptmxmode=000)  
tmpfs on /run type tmpfs (rw,nosuid,relatime,size=204220k,mode=755)  
/dev/sda1 on / type ext4 (rw,relatime,errors=remount-ro,data=ordered)  
securityfs on /sys/kernel/security type securityfs (rw,nosuid,nodev,noexec,relatime)  
tmpfs on /dev/shm type tmpfs (rw,nosuid,nodev)  
tmpfs on /run/lock type tmpfs (rw,nosuid,nodev,noexec,relatime,size=5120k)  
tmpfs on /sys/fs/cgroup type tmpfs (ro,nosuid,nodev,noexec,mode=755)  
cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/lib/systemd/systemd-cgroups-agent,name=systemd)  
pstore on /sys/fs/pstore type pstore (rw,nosuid,nodev,noexec,relatime)  
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)  
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpu,cpuacct)  
cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)  
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)  
cgroup on /sys/fs/cgroup/net_cls,net_prio type cgroup (rw,nosuid,nodev,noexec,relatime,net_cls,net_prio)  
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)  
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)  
systemd-1 on /proc/sys/fs/binfmt_misc type autofs (rw,relatime,fd=23,pgrp=1,timeout=300,minproto=5,maxproto=5,direct)  
mqueue on /dev/mqueue type mqueue (rw,relatime)  
debugfs on /sys/kernel/debug type debugfs (rw,relatime)  
hugetlbfs on /dev/hugepages type hugetlbfs (rw,relatime)  
rpc_pipefs on /run/rpc_pipefs type rpc_pipefs (rw,relatime)  
/dev/etherd/e0.1p1 on /mnt type ext4 (rw,relatime,data=ordered)  
root@server1:/tmp#

… e

df -h

root@server1:/tmp# df -h  
Filesystem Size Used Avail Use% Mounted on  
/dev/sda1 57G 1.1G 54G 2% /  
udev 10M 0 10M 0% /dev  
tmpfs 200M 4.6M 195M 3% /run  
tmpfs 499M 0 499M 0% /dev/shm  
tmpfs 5.0M 0 5.0M 0% /run/lock  
tmpfs 499M 0 499M 0% /sys/fs/cgroup  
/dev/etherd/e0.1p1 20G 44M 19G 1% /mnt  
root@server1:/tmp#

Puoi smontarlo in questo modo:

umount /mnt

Per avere il dispositivo montato automaticamente all’avvio, ad esempio nella directory /storage, creiamo quella directory…

mkdir /storage

… e aggiungiamo la seguente riga a /etc/fstab:

nano /etc/fstab

[...]  
/dev/etherd/e0.1p1       /storage        ext4    defaults,auto,_netdev 0 0

Questo da solo non è sufficiente per avere il dispositivo montato all’avvio perché le cose AoE vengono caricate dopo che /etc/fstab è stato letto. Pertanto apriamo /etc/rc.local…

nano /etc/rc.local

… e aggiungiamo le seguenti righe (prima della riga exit 0):

[...]  
aoe-discover  
sleep 5  
mount -a  
[...]

Per scopi di test, ora puoi riavviare il sistema:

reboot

Dopo il riavvio, il dispositivo dovrebbe essere montato:

mount

root@server1:/tmp# mount  
[...snip...]  
/dev/etherd/e0.1p1 on /storage type ext4 (rw,relatime,data=ordered)  
[...snip...]

df -h

root@server1:/tmp# df -h  
Filesystem Size Used Avail Use% Mounted on  
/dev/sda1 57G 1.1G 54G 2% /  
udev 10M 0 10M 0% /dev  
tmpfs 200M 4.6M 195M 3% /run  
tmpfs 499M 0 499M 0% /dev/shm  
tmpfs 5.0M 0 5.0M 0% /run/lock  
tmpfs 499M 0 499M 0% /sys/fs/cgroup  
/dev/etherd/e0.1p1 20G 44M 19G 1% /storage

Ora possiamo fare una scrittura di prova sulla partizione montata:

touch /storage/test.txt

Controlla con il comando ls se il file è stato scritto:

ls -la /storage

root@server1:/tmp# ls -la /storage  
total 24  
drwxr-xr-x 3 root root 4096 Mar 22 09:06 .  
drwxr-xr-x 23 root root 4096 Mar 22 09:05 ..  
drwx------ 2 root root 16384 Mar 22 09:00 lost+found  
-rw-r--r-- 1 root root 0 Mar 22 09:06 test.txt  
root@server1:/tmp#

Il file test.txt è stato scritto con successo sul volume che abbiamo montato da server2.

5 Link

Definizione del Protocollo AoE: http://www.coraid.com/RESOURCES/AoE-Protocol-Definition
Debian: http://www.debian.org/

1 Nota Preliminare

2 Caricare il Modulo del Kernel AoE su entrambi i sistemi

3 Impostare la Destinazione (server2)

4 Impostare il Client AoE / Inizializzatore (server1)

5 Link

Ricevi i nuovi post nella tua casella di posta.