Archivi Categorie: file system

Creare un disco immagine criptato

luks

# PREPARAZIONE IMMAGINE DISCO su FILE

luca@bluefish /tmp $ sudo dd if=/dev/zero of=/tmp/vdisk.img bs=10M count=1
1+0 record dentro
1+0 record fuori
10485760 byte (10 MB) copiati, 0,0106805 s, 982 MB/s

# MARCHIO con LUKS

luca@bluefish /tmp $ sudo cryptsetup -y -v luksFormat /tmp/vdisk.img

WARNING!
========
Ciò sovrascriverà i dati in /tmp/vdisk.img in modo irreversibile.

Are you sure? (Type uppercase yes): YES
Inserire la passphrase:
Verify passphrase:
Comando eseguito con successo.

# SBLOCCO IL DEVICE

luca@bluefish /tmp $ sudo cryptsetup open /tmp/vdisk.img vdisk
Inserire la passphrase per /tmp/vdisk.img:
# FORMATTO il DEVICE
luca@bluefish /tmp $ sudo mkfs.ext4 /dev/mapper/vdisk
mke2fs 1.42.9 (4-Feb-2014)
Etichetta del filesystem=
OS type: Linux
Dimensione blocco=1024 (log=0)
Dimensione frammento=1024 (log=0)
Stride=0 blocks, Stripe width=0 blocks
2048 inodes, 8192 blocks
409 blocks (4.99%) reserved for the super user
Primo blocco dati=1
Maximum filesystem blocks=8388608
1 block group
8192 blocchi per gruppo, 8192 frammenti per gruppo
2048 inode per gruppo

Allocating group tables: fatto
Scrittura delle tavole degli inode: fatto
Creating journal (1024 blocks): fatto
Scrittura delle informazioni dei superblocchi e dell'accounting del filesystem: fatto

# MONTARE ed USARE il VOLUME CRIPTATO

luca@bluefish /tmp $ sudo mount /dev/mapper/vdisk /mnt/vdisk

luca@bluefish /tmp $ sudo vim /mnt/vdisk/LEGGIMI.txt

luca@bluefish /tmp $ ls -l /mnt/vdisk/
totale 13
-rw-r--r-- 1 root root 18 nov 16 15:57 LEGGIMI.txt
drwx------ 2 root root 12288 nov 16 15:56 lost+found

# SMONTARE TUTTO

luca@bluefish /tmp $ umount /mnt/vdisk
umount: /mnt/vdisk non si trova in fstab (e non si è root)

luca@bluefish /tmp $ sudo umount /mnt/vdisk
luca@bluefish /tmp $ sudo cryptsetup close vdisk

 

Annunci

ZFS: l’ultimo file system

zfs-linux
Storia

ZFS è un file system open source sviluppato dalla Sun Microsystems per il suo sistema operativo Solaris annunciato nel 2004.
È stato eseguito il porting su Linux. È da notare che, a causa della licenza che protegge ZFS, esso non può essere integrato nel kernel ma deve necessariamente operare a livello utente tramite FUSE: questo vincolo preclude qualunque utilizzo di ZFS su GNU/Linux in attività di produzione, in quanto un filesystem a livello utente non è accettabile per prestazioni e stabilità. Tuttavia, è possibile utilizzare ZFS come modulo esterno, permettendo agli utenti di utilizzare questo file system con prestazioni native, attraverso il progetto ZFS on Linux.

Vantaggi

  • Capacità: 128-bit contro i 32-bit di altri file system quindi enorme capacità del filesystem (fino a 2^128 byte)
  • Protezione avanzata dei dati: checksum e strutture dati sempre congruenti
  • Sempre online: nessuna necessità di mettere lo storage offline per svolgere compiti amministrativi
  • Operatività più veloce: qualche secondo per creare un nuovo file system
  • Riduzione dei costi: amministrazione più semplice e gestione flessibile dei volumi con funzionalità automatiche di bilanciamento dinamico del carico e logging
  • Integra file system con volume manager
  • Compressione
  • Snapshot rapidi

Installazione su Ubuntu:

in user space:
apt-get install zfs-fuse

in kernel space:
add-apt-repository ppa:zfs-native/stable
apt-get update
apt-get install ubuntu-zfs

Laboratorio 1: raidz

Creare un pool in **raidz (raid5)**

Requisiti: n dischi stessa dimensione. Se non sono della stessa dimensione, partizionare e usare la parzione


fdisk -l | grep dev
Disco /dev/sdb: 1073 MB, 1073741824 byte
Disco /dev/sdc: 1073 MB, 1073741824 byte
Disco /dev/sdd1: 1073 MB, 1073741824 byte
Disco /dev/sde: 1073 MB, 1073741824 byte
Disco /dev/sdf: 1073 MB, 1073741824 byte

preparazione del pool: (una sorta di raggruppamento dei device in volumi)

zpool create TANK raidz /dev/sdb /dev/sdc /dev/sdd1 /dev/sde /dev/sdf
zpool status

creazione del FS: (creazione del FS vero e proprio)

zfs create TANK/vol1

zfs list
NAME USED AVAIL REFER MOUNTPOINT
TANK 468M 3,45G 35,1K /TANK
TANK/vol1 467M 3,45G 467M /TANK/vol1

opzioni:

zfs set compression=on TANK/vol1

tests:

zpool offline TANK /dev/sdb
zpool status

zpool offline TANK /dev/sdb
zpool status

scollegare fisicamente 1 disco e vedere cosa accade. dare un:

zpool scrub TANK

esportare volume (smontaggio e spegnimento volumi)

zpool export TANK

Laboratorio 2: mirror

Distruggere il pool precedente per riutilizzare i dischi:

zpool destroy TANK /dev/sdb /dev/sdc

preparazione del pool:

zpool create TANK2 mirror c1t0d0 c2t0d0
zpool status

creazione del FS:

zfs create TANK2/volume-sicuro
zfs list

RAID software su Linux

raid1
Definizione (da Wikipedia)
“Un RAID, acronimo di Redundant Array of Inexpensive Disks, insieme ridondante di dischi economici (oppure Redundant Array of Independent Disks, in italiano insieme ridondante di dischi indipendenti), è un sistema informatico che usa un gruppo di dischi rigidi per condividere o replicare le informazioni. I benefici del RAID sono di aumentare l’integrità dei dati, la tolleranza ai guasti e le prestazioni, rispetto all’uso di un disco singolo. Nella sua implementazione originaria il fattore chiave era l’abilità di combinare parecchi dischi a basso costo ed obsoleti per rendere il sistema complessivamente migliore di un disco di ultima generazione per capacità, affidabilità e velocità.”

Scopo
Creare un mirror (raid1) di 2 dischi e usare in parallelo e contemporaneamente 2 dischi. Ciò che viene scritto sul primo disco, viene scritto anche sil secondo, così, nel caso in cui uno dei 2 si dovesse guastare, tutto continuerà a funzionare per via della ridondanza.

Questo può poi essere sostituito con un nuovo, quando inserito nel nostro “pool”, si avvierà la sincronizzazione.
I dischi del pool possono essere n, non necessariamente 2.
Questo non prevenie però la cancellazione accidendale o sovrascrizione di un file: la stessa operazione avviene istantaneamente su tutti i dischi
dell’array.
Per recuperare un file così perduto, bisongerà fare ricorso a una copia di backup.

Requisiti
2 dischi o device liberi di uguale dimensione (si possono usare sia dischi non partizionati, sia partizioni o device. Se i dischi fisici hanno dimensione diversa, creare 2 partizioni della medesima dimensione).
Per preparare le partizioni, usare fdisk da riga di comando oppure palimsest o (il suo rimpiazzo) gnome-disks da interfaccia grafica.

Installazione
mdadm è lo strumento standard di gestione del RAID disponibile su Linux.
Si trova in qualsiasi distribuzione moderna. Per installarlo sul nostro sistema si può utilizzare il comando:

sudo apt-get install mdadm

Installerà anche il pacchetto postfix per comunicare via email eventuali problemi del raid.

Creazione
Ora possiamo creare il nostro RAID, la sintassi è la seguente:

mdadm --create /dev/md0 --level=mirror --raid-devices=2 /dev/sdb1 /dev/sdc1
mdadm: Defaulting to version 1.2 metadata
mdadm: array /dev/md0 started.

Questo creerà il dispositivo virtuale /dev/md0 creato da due dispositivi a blocchi reali /dev/sdb1 e /dev/sdc1, configurandolo in modalità mirror.

Creato il raid, andrà creato sopra un filesystem, anche se i 2 device non sono ancora sincronizzati.
Per verificare lo stato della sincronizzazione lanciare il comando:

cat /proc/mdstat
Personalities : [raid1]
md0 : active raid1 sdc1[1] sdb1[0]
488253440 blocks super 1.2 512K chunks 2 far-copies [2/2] [UU]
[>....................] resync = 0.3% (1625024/488253440) finish=169.9min speed=47730K/sec

La ricostruzione viene fatta usando la banda di I/O non utilizzata. Quindi, il sistema dovrebbe essere ancora abbastanza reattivo.

Creazione il file di configurazione mdadm.conf
All’avvio il sistema esegue una scansione di tutti i dispositivi e attiva automaticamente i raid, quindi non è necessario avere un file mdadm.conf configurato, ma è comunque consigliabile scrivere la configurazione Raid, in Debian questo file si trova in /etc/mdadm/mdadm.conf e il modo più semplice per configurarlo è quello di utilizzare il seguente comando:

sudo mdadm --detail --scan --verbose > /etc/mdadm/mdadm.conf

Ad esempio il file contiene:

ARRAY /dev/md0 level=raid1 num-devices=2 metadata=1.2 name=mint-desktop:0 UUID=048c40d4:16d71dda:1c3ba4ca:8babae51
devices=/dev/sdb1,/dev/sdc1

Creare un filesystem sul metadevice Raid
Formatteremo ora il dispositivo, mentre la ricostruzione è in esecuzione.
Inoltre è possibile montarlo e usarlo mentre la ricostruzione è in esecuzione.
E’ possiible scegliere qualunque tipo di filesystem.

sudo mkfs.ext4 /dev/md0

Tale operazione è terminata senza errori in pochi secondi anche se il mirror è ancora in ricostruzione.
Si crea il mount point e monto il nuovo filesystem su di esso con:

sudo mkdir /HOMERAID
sudo mount /dev/md0 /HOMERAID
sudo chmod 777 /HOMERAID # I want all users to be able to work there
sudo chmod +t /HOMERAID #But i want that only the owner can delete their contents.
tune2fs -m 1 /dev/md0 #reserve just 1% of the disk for maintenance

E come ultima si aggiunge una riga al file /etc/fstab, in modo che il raid venga montato automaticamente in /HOMERAID durante il processo di avvio

echo "/dev/md0 /HOMERAID/ ext4 defaults 1 2" >> /etc/fstab

LVM: Logical Volume Manager

lvm2

Nel 2010 ho avuto una esperienza su HP-UX in HP dove si utilizza moltissimo LVM. In questa occasione sono venuto in contatto con LVM..

LVM (gestore logico dei volumi) è un software di gestione dei dischi disegnato per essere più flessibile del normale partizionamento fisico.
Si potrebbe pensare ad LVM come un sottile strato software in cima ai dischi rigidi ed alle partizioni che crea una illusione di continuità e semplicità per la gestione delle sostituzioni, dei ripartizionamenti e delle copie di sicurezza dei dischi rigidi.

lvm-strati

Nell’ambito casalingo, il classico partizionamento usato nella maggior parte delle installazioni è quello basato su MBR (Master Boot Record) e tabella delle partizioni MSDOS.
Con questo sistema è possibile avere un massimo di 4 partizioni primarie oppure fino a 3 partizioni primarie, una partizione estesa e all’interno di quest’ultima infinite partizioni logiche.
Il limite principale di questa architettura è dato dalla rigidità di questa organizzazione delle risorse. Le partizioni sono fisse e non possono essere separate in più dischi, non possono essere modificate senza smontarle e lo spazio per il file system è quello prefissato, non può né crescere né diminuire senza smontare tutto e rifare le partizioni.
Immaginando un’installazione multiutente, se il disco viene completamente riempito l’unica soluzione è quella di acquistare un disco nuovo e travasare i dati in quello, reimpostando i permessi com’erano in origine con elevati costi di tempo, oppure spostare i dati altrove, soluzione ovviamente non facilmente applicabile in multiutenza.
LVM rivoluziona il concetto di organizzazione dello spazio fornendo un sistema di allocazione dinamica dello spazio.

Nell’ambito aziendale, LVM può gestire grandi batterie di dischi rigidi consentendo l’aggiunta di dischi, la sostituzione, la copia e la condivisione di contenuti da un disco a un altro senza interruzione del servizio.
E’ in grado di effettuare dei backup facendo degli snapshot, puo’ mostrare n dischi fisici come uno unico, oppure 1 solo disco fisico (o LUN o altro) come tanti volumi logici (LV) raggruppati a piacimento dentro diversi gruppi di volume (VG).

Caratteristiche:
– ridimensionare i Gruppi di Volume online assorbendo nuovi Volumi Fisici oppure espellendo quelli facentene parte
– ridimensionare i Volumi Logici online concatenando le ampiezze su di loro o troncando le ampiezze da loro
– creare fotografie Volumi Logici
– ripartire per intero o in parte Volumi Logici attraverso multipli Volumi Fisici, in modo simile al Raid 0
– fare una copia per intero o in parte di Volumi Logici, in modo simile al Raid 1
– spostare online i Volumi Logici tra i Volumi Fisici

I passi per creare un volume logico sono:
– preparare i dischi: si preparano i PhysicalVolume (PV); LVM marchia i dischi fisici come suoi col comando pvcreate
– creare un gruppo: si definisce un VolumeGroup (VG) ossia un contenitore/gruppo per i LV col comando vgcreate
– creare i volumi: dentro il gruppo (VG) si definiscono i LogicalVolume (LV), in pratica l’equivalente della partizioni nel sistema classico. I LV sono i nostri device su cui lavoreremo, ovvero ove creeremo i FS.
– ceazione file system: dentro il LogicalVolume (LV) creiamo il filesystem che preferiamo!

Sembra complicato, ma fissata la struttura bene in testa, si apprezzerà moltissimo la potenza e flessibilità di LVM!

Struttura:

La struttura del LVM è, come intuito dai passi per crearlo, come segue:
– ogni disco fisico ha delle partizioni
– su ogni partizione si crea un PV
– raggruppo i PV in un VG (definento la sua dimensione massima, di default uguale alla somma dei PV)
– dentro il VG creo diversi LV, di diversa dimensione, al massimo fino alla dimensione del VG
– sul LV creo il FS che desidero della dimensione che desidero (anche inferiore alla dimensione del LV)

Legenda da imparare a memoria:
PV: PhysicalVolume
VG: VolumeGroup
LV: LogicalVolume
FS: FileSystem

pv-vg

Se volessimo analizzare la struttura di LVM ad un livello più basso:
– ogni PV viene spezzettatto in piccoli PE (PhysicalExtends) di dimensione tutti uguale per ogni PV, di default 4 MB
– ogni LV viene diviso in senso logico, in pezzetti detti LE (LogicalExtends) i quali sono associati ad un unico PE

Legenda da imparare a memoria:
PE: PhysicalExtend
LE: LogicalExtend

pvle

Ad esempio:
il LE1 del LV “Pippo” punta al PE1 del PV1
il LE2 del LV “Pippo” punta al PE2 del PV1
il LE3 del LV “Pippo” punta al PE3 del PV3
il LE4 del LV “Pippo” punta al PE1 del PV2
il LE5 del LV “Pippo” punta al PE2 del PV2
il LE1 del LV “Pluto” punta al PE4 del PV1

Questa associazione è necessaria per svincolare i volumi fisici (PV) da quelli logici. Necessario ad esempio quando viene aggiunto un nuovo PV e si vuole espandere il LV. Una situazione frammentata come quella dell’esempio si ha infatti proprio con variazioni come l’aggiunta o sottrazione di PV, altrimenti in genere si ha una situazione abbastanza lineare, cioè LEx->PEx.
HP-UX (su cui è stato creato LVM) ha alcuni comandi di basso livello per mostrare la distribuzione dei LE e PE.

Laboratorio di LVM

in lavorazione…

Luca

BTRFS: Il file system del futuro

btrfs

Sono sempre stato affascianto dall’archiviazione massiva dei dati. Con BTRFS si possono fare cose pazzesche, è lo ZFS del mondo linux

Btrfs (Butter Filesystem) è un nuovo file system ancora sotto sviluppo paragonabile a ZFS che offre funzionalità sorprendenti.
La terminologia usata con BTRFS crea un po’ di confusione, se si ha dimestichezza con ZFS o LVM si troveranno molte analogie.
Il termine “volume” corrisponde al termine “pool” in ZFS o “Volume Group” in LVM.
Tra le principale caratteristiche di BTRFS troviamo:

– Conversione tra filesystem EXT3, EXT4 e BTRFS;
– Deframmentazione a caldo
– Resize (diminuzione o ingrandimento dei dischi) a caldo!
– Supporto RAID 0, RAID 1 e RAID 10
– Efficiente backup incrementale ed il mirroring FS
– Controllo del file system montato on-line ed offline, entrambi in modo molto veloce
– Checksum su dati e metadati, questa è una delle garanzie per mantenere l’integrità dei dati memorizzati
– L’allocazione dinamica degli inode
– Compressione con zlib e LZO
– Efficienza di organizzazione dei file e directory
– Dimensione massima dei file è di 16 exabyte
– Creazione di snapshot del disco montato, ossia un backup in tempo reale dell’intero sistema

A questa pagina http://www.rkeene.org/projects/info/wiki.cgi/165 vengono comparati i comandi tra btrfs, ZFS e LVM con ext4.
A questa pagina troverete un interessante articolo a riguardo.

Giochiamo col BTRFS
Ritagliatevi un po’ di tempo e armatevi di un po’ pazienza (preparatevi una tazza di te e mettete un buon brano di sottofondo) e cominciamo a fare qualche test su questo file system..

Cominciamo a preparare un gruppo di dischi per i nostri test:

dd if=/dev/zero of=/tmp/btrfs-vol0.img bs=512M count=1
dd if=/dev/zero of=/tmp/btrfs-vol1.img bs=512M count=1
dd if=/dev/zero of=/tmp/btrfs-vol2.img bs=512M count=1
dd if=/dev/zero of=/tmp/btrfs-vol3.img bs=512M count=1
dd if=/dev/zero of=/tmp/btrfs-vol4.img bs=512M count=1

Colleghiamoli:

losetup /dev/loop0 /tmp/btrfs-vol0.img
losetup /dev/loop1 /tmp/btrfs-vol1.img
losetup /dev/loop2 /tmp/btrfs-vol2.img
losetup /dev/loop3 /tmp/btrfs-vol3.img
losetup /dev/loop4 /tmp/btrfs-vol4.img

Il comportamento di default (senza specificare opzioni) è il seguente:
metadata replicati su tutti i device. Se si usa un solo device, un metadata rovinato comporta la morte del volume con nessuna possibilità di recupero del volume.
dati spalmati su tutti i device (questo significa nessuna ridondanza; qualsiasi dato lasciato su un device difettoso non sarà accessibile)

Creiamo un volume BTRFS composto da più device (i metadata replicati su tutti i dischi):

mkfs.btrfs /dev/loop0 /dev/loop1 /dev/loop2

Creiamo un volume BTRFS composto da un singolo device con una sola copia dei metadata (pericoloso):

mkfs.btrfs -m single /dev/loop0

Creiamo un volume BTRFS composto da più device con metadati spalmati su tutti i device:

mkfs.btrfs -m raid0 /dev/loop0 /dev/loop1 /dev/loop2

Per creare un volume BTRFS completamente ridondato (composto da più device, con dati e metadati mirrorati su tutti i device):

mkfs.btrfs -d raid1 /dev/loop0 /dev/loop1 /dev/loop2

Per verificare da quali device è composto un volume BTRFS usare

btrfs-show device (old style)

oppure

btrfs filesystem show /dev/loop0
btrfs filesystem show (mostra tutti)

risultato:
Label: none uuid: 0a774d9c-b250-420e-9484-b8f982818c09
Total devices 3 FS bytes used 28.00KB
devid 3 size 1.00GB used 263.94MB path /dev/loop2
devid 1 size 1.00GB used 275.94MB path /dev/loop0
devid 2 size 1.00GB used 110.38MB path /dev/loop1

Montare un volume

I volumi BTRFS vengono montati come ogni altro filesystem:
(basta dare uno dei device)
mount /dev/loop0 /mnt

Controllo dello spazio
col comando df -h il risultato per ogni device fisico è il medesimo:

# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/loop1 3.0G 56K 1.8G 1% /mnt

Maggiori informazioni possono essere ottenute col comando:

# btrfs filesystem df /mnt
Data, RAID0: total=409.50MB, used=0.00
Data: total=8.00MB, used=0.00
System, RAID1: total=8.00MB, used=4.00KB
System: total=4.00MB, used=0.00
Metadata, RAID1: total=204.75MB, used=28.00KB
Metadata: total=8.00MB, used=0.00

Diminuire il volume (shrinking)
btrfs filesystem resize -500m /mnt
Ebbene sì! Ha fatto un ridimensionamento al volo.
Ma attenzione, un ridimensionamento troppo aggressivo non funzionarà, btrfs richiede uno spazio minimo:

btrfs filesystem resize -1g /mnt
Resize '/mnt' of '-1g'
ERROR: unable to resize '/mnt'

Aumentare il volume (growing)

btrfs filesystem resize +150m /mnt
Resize '/mnt' of '+150m'

Si può anche usare l’opzione “max” per usare il massimo spazio disponibile:
btrfs filesystem resize max /mnt

Aggiungere un nuovo device al volume BTRFS

btrfs device add /dev/loop4 /mnt
btrfs filesystem show /dev/loop4
Label: none uuid: 0a774d9c-b250-420e-9484-b8f982818c09
Total devices 4 FS bytes used 28.00KB
devid 3 size 1.00GB used 263.94MB path /dev/loop2
devid 4 size 1.00GB used 0.0 path /dev/loop4
devid 1 size 1.00GB used 275.00MB path /dev/loop0
devid 2 size 1.00GB used 110.00MB path /dev/loop1

Ovviamente non c’è bisogno di smontare nulla, si fa tutto online, ma il device per ora non è usato (used 0.0 MB).
Per metterlo in funzione bisogna dire a BTRFS di preparare il nuovo device (esempio di ribilanciare/mirrorare i metadati e dati su tutti i device).

btrfs filesystem balance /mnt
btrfs filesystem show /dev/loop4
Label: none uuid: 0a774d9c-b250-420e-9484-b8f982818c09
Total devices 4 FS bytes used 28.00KB
devid 3 size 1.00GB used 110.38MB path /dev/loop2
devid 4 size 1.00GB used 366.38MB path /dev/loop4
devid 1 size 1.00GB used 378.38MB path /dev/loop0
devid 2 size 1.00GB used 110.38MB path /dev/loop1

Continua…

Luca