Nessuno di noi è immune dagli errori. A volte la sindrome delle mani storte porta a conseguenze molto tristi. A volte è molto difficile resistere e non condurre esperimenti "antiscientifici" con il sistema o eseguire uno script / applicazione scaricato da una fonte non verificata. E qui vengono in soccorso vari strumenti per l'esecuzione di applicazioni in un ambiente isolato e funzionalità estese del file system.
I sistemi *nix sono sempre stati relativamente resistenti alle applicazioni scritte male (a condizione, ovviamente, che non fossero eseguite come root). Tuttavia, a volte c'è il desiderio di sperimentare con il sistema: scherzare con le configurazioni, alcune delle quali possono essere vitali, eseguire uno script sospetto, installare un programma ottenuto da una fonte non attendibile ... Altrimenti, la paranoia semplicemente vince e voglio costruire quante più barriere possibili per proteggersi da potenziali malware. L'articolo descriverà alcuni mezzi per evitare le conseguenze di errori non forzati eseguendo il rollback a un punto di ritorno creato in precedenza (istantanee Btrfs), eseguendo un programma sospetto in un ambiente limitato e divertendo la tua paranoia (Arkose e chroot).
Chroot è noto da molto tempo. Ha un enorme vantaggio rispetto ad altri strumenti: funziona ovunque, anche su distribuzioni molto vecchie. Tutti questi nuovi sandbox non sono altro che il suo ulteriore sviluppo. Ma ci sono anche degli svantaggi. Ad esempio, non c'è modo di limitare la rete, root può uscirne con un certo sforzo e, soprattutto, è abbastanza difficile configurarlo. Nonostante ciò, per alcuni scopi, come l'installazione di pacchetti dai sorgenti, è l'ideale.
Ci sono almeno tre modi per creare un ambiente chroot:
Molto probabilmente, durante l'avvio dalla partizione Btrfs, Grub giurerà che i file sparsi non sono consentiti e ti chiederà di premere un tasto qualsiasi. Per evitare che questo messaggio venga visualizzato, aprilo nel tuo preferito editor di testo file /etc/grub.d/00.header e commenta la seguente riga lì:
If [ -n "\$(have_grubenv)" ]; allora if [ -z "\$(boot_once)" ]; poi save_env recordfail; fi; fi
In realtà, la variabile recordfail è necessaria per impedire un riavvio ciclico, per il quale viene armata all'avvio, quindi, in caso di caricamento riuscito, viene impostata su 0. Sebbene sia indesiderabile commentare il codice responsabile di questa procedura, Penso che su un sistema desktop sia abbastanza possibile farne a meno.
Ognelis nella sandbox: questo è ciò che dice il titolo
Per prima cosa, installiamo il pacchetto debootstrap, che viene utilizzato proprio per questo scopo.
$ sudo apt-get install debootstrap
Quindi creeremo una directory in cui si troverà il chroot e vi distribuiremo il sistema quantistico di base. In generale, può essere creato ovunque, ma la sua posizione tradizionale è /var/chroot. Poiché la maggior parte dei seguenti comandi richiedono permessi di root, ha senso passare all'account superutente:
$ sudo su - # mkdir /var/chroot && cd /var/chroot # debootstrap quantal ./quantal-chr1 http://mirror.yandex.ru/ubuntu
Diamo un'occhiata all'ultimo comando. Distribuisce la versione Quantal Ubuntu in una directory quantal-chr1 separata (non si sa mai, improvvisamente hai bisogno di un altro chroot) dal mirror più vicino. Al termine della distribuzione, è necessario mappare i file system procfs, sysfs e (se applicabile) la directory /dev a questo sottoalbero. Nel caso in cui il chroot venga utilizzato solo per applicazioni di testo fino al riavvio, dovrebbero essere sufficienti i seguenti comandi:
# mount --bind /proc /var/chroot/quantal-chr1/proc # mount --bind /sys /var/chroot/quantal-chr1/sys # mount --bind /dev /var/chroot/quantal-chr1/ dev
Se vuoi che questo sottoalbero funzioni dopo un riavvio, aggiungi le righe appropriate a /etc/fstab. Bene, per il lavoro di alcuni applicazioni grafiche dovrebbero essere visualizzate anche le directory /tmp e /var/run/dbus. Successivamente, puoi già inserire il seguente comando, che, di fatto, crea il chroot:
# chroot /var/chroot/quantal-chr1/
E tu ci sei già bloccato. Per non confondere chroot con un sistema reale, consiglio di cambiare il prompt della shell. Ad esempio, installiamo ed eseguiamo Skype nel chroot. Per fare ciò, è necessario installare il pacchetto schroot sul sistema host, che semplifica l'esecuzione di programmi in un ambiente chroot:
Distribuzione al chroot del sistema di base utilizzando debootstrap # apt-get install schroot Quindi aggiungiamo una voce al file /etc/schroot/schroot.conf. Nel mio caso ho aggiunto quanto segue:
/etc/schroot/schroot.conf description=Quantal directory Skype=/var/chroot/quantal-chr1 priority=3 utenti=rom gruppi=rom root-groups=root,rom
Inoltriamo /dev, /proc, /sys, /tmp e /var/run/dbus - vedi sopra per come farlo. Aggiungi un utente e un gruppo skype al chroot: è auspicabile che uid e gid corrispondano all'uid / gid dell'utente principale del sistema reale (nel mio caso, rom), per il quale digitiamo i seguenti comandi:
# schroot -c quantal-skype -u root # addgroup --gid 1000 skype # adduser --disabled-password --force --uid 1000 --gid 1000 skype
Successivamente, inseriamo Skype appena scaricato, sempre nel chroot, e soddisfiamo le sue dipendenze:
# dpkg --force-all -i skype-ubuntu-precise_4.1.0.20-1_i386.deb # apt-get -f install # esci
Sul sistema principale, consentiamo le connessioni al server X da localhost e inseriamo il chroot come utente normale:
$ xhost +localhost $ cd / && schroot -c quantal-skype -u rom /bin/bash
Imposta la variabile DISPLAY (che devi guardare nel sistema principale) e avvia Skype:
$ export DISPLAY=":0.0" $ skype --dbpath=/home/skype/.Skype &
Skype è stato installato e avviato correttamente in un ambiente chroot.
Sarebbe possibile scrivere uno script per facilitare il lancio, ma puoi farlo da solo.
Arkose funziona in modo simile alle sandbox di Windows, come Sandboxie. In pratica si tratta di un comodo involucro per contenitori LXC. Ma, come sai, praticità e flessibilità a volte sono incompatibili: è difficile mettere a punto i contenitori creati. Tra i vantaggi, noto un'interfaccia intuitiva (questo è se si utilizza la GUI, tuttavia, l'avvio da riga di comandoè anche molto semplice), ma tra gli svantaggi: per impostazione predefinita richiede molto spazio libero sul disco rigido e ce ne sono alcuni modi possibili circonvallazione; ma, se usi Arkose come wrapper aggiuntivo per potenziali modi per introdurre malware (browser) o anche solo per sperimentare alcuni applicazione interessante, non farà male.
Seccomp è un meccanismo poco conosciuto introdotto nel kernel 2.6.12 che consente a un processo di eseguire una transizione unidirezionale verso uno stato "sicuro", in cui sono disponibili solo quattro chiamate di sistema: exit(), sigreturn(), read() e write(), e gli ultimi due sono disponibili solo per già file aperti. Se il processo tenta di chiamare qualsiasi altra chiamata di sistema, verrà ucciso immediatamente.
Ovviamente questa soluzione non è molto flessibile. A questo proposito, nel kernel 3.5 è apparso seccomp-bpf, che permette di mettere a punto, usando le regole BPF, quali chiamate di sistema (e i loro argomenti) sono permesse e quali no. Seccomp-bpf è usato in Google Chrome, Chrome OS e backport su Ubuntu 12.04.
Prima di utilizzare Arkose, deve essere installato. La procedura è standard:
$ sudo apt-get install arkose-gui
Verranno installate sia la GUI (arkose-gui) che l'utilità della riga di comando (arkose). L'interfaccia grafica è così semplice che non vedo l'utilità di descriverla, è meglio passare subito alla pratica.
Creazione manuale Avviamo Firefox come esempio:
$ sudo arkose -n direct -p firefox
Questo comando avvierà Firefox con accesso web e PulseAudio. Poiché ogni contenitore appena creato ha la propria home directory per impostazione predefinita, anche il profilo firelis sarà nuovo, senza componenti aggiuntivi installati, se presenti.
"Ma aspetta! Perché Sudo? - potrebbe sorgere una domanda ragionevole. Il fatto è che alcune operazioni preparatorie sono disponibili solo da root. Tuttavia, mi affretto a rassicurarti: il programma avviato funzionerà con i diritti dell'utente corrente.
Aggiunta di un utente per eseguire Skype in chroot Succede che dopo aver installato gli aggiornamenti, il sistema crolla. Strumenti simili al componente Ripristino configurazione di sistema di Windows sarebbero utili qui. Sono orgoglioso di dire che li abbiamo! E uno di questi strumenti è Btrfs. Tra i vantaggi del nuovo file system di Oracle, vale la pena notare quanto segue:
Per eseguire operazioni su un file system di nuova generazione, come la creazione di istantanee, la deframmentazione di un volume e molti altri, viene utilizzato il comando btrfs. La sua sintassi, in generale, è la seguente:
btrfs<команда> <аргументы>
Che tipo di operazioni possono essere eseguite su Btrfs? Di seguito sono riportati i comandi che ho trovato interessanti.
I restanti comandi, sebbene interessanti, sono legati all'argomento dell'articolo solo nella misura in cui, e non li prenderemo in considerazione. Quindi, per creare un'istantanea di un sottovolume con la data corrente, ad esempio la directory principale, digitiamo il seguente comando:
$ sudo btrfs subvol snap -r / /snapshot-2013-01-16
$ sudo btrfs subvol del /snapshot-2013-01-16
Un sottovolume Btrfs può agire in due modi: come directory e come oggetto VFS, qualcosa che può essere montato. Ad esempio, durante l'installazione di Ubuntu, vengono creati due sottovolumi: @ e @home. Il primo contiene file di sistema, il secondo sono i dati dell'utente. Questo è simile al partizionamento di un disco, solo se prima una partizione poteva contenere, di regola, solo un oggetto VFS, ora possono esserci più oggetti su una partizione contemporaneamente e possono essere nidificati.
Non vedo molto senso creare istantanee manualmente: puoi semplicemente dimenticarti di farlo. Mi vengono in mente tre scenari di automazione:
Sfortunatamente, in Ubuntu 12.10 l'ultimo metodo non è disponibile per qualche motivo, quindi praticamente non c'è scelta in quanto tale. Personalmente, ho preferito scrivere uno script cron, ma prima creiamo un sottovolume in cui verranno archiviate le nostre istantanee. Per quello? Almeno per non sporcare la cartella principale.
# mkdir /mnt/sda11 # mount /dev/sda11 /mnt/sda11 # btrfs subvol create /mnt/sda11/@snapshots # umount /mnt/sda11
Vediamo cosa fanno questi comandi. Poiché la radice effettiva di FS in questo momento inaccessibile (in ubuntu, subvolume @ è invece usato come root), dobbiamo montarlo manualmente. Nel mio caso è su /dev/sda11. Con il terzo comando, creiamo il sottovolume @snapshots, quindi se non lo montiamo o non montiamo la radice reale, il suo contenuto sarà inaccessibile. E ora la sceneggiatura vera e propria:
Autosnap.sh #!/bin/bash set -e VOLUME=/dev/sda11 TMP_PATH=/tmp/snapshots MOUNT_OPTS=" [e-mail protetta]" # Data e ora correnti - necessarie per denominare le cartelle delle istantanee NOW="$(date +%Y%m%d%H%M)" NOW_SEC="$(date +%s)" if [ $# -ne 1 ] ; then # Se lo script viene eseguito senza argomenti, imposta il valore predefinito su un giorno fa OLDER_SEC="$(date --date "1 giorno fa" +%s)" else # Se abbiamo un argomento, assumiamo che sia una data in qualsiasi formato comprensibile dal comando date, con tutte le conseguenze OLDER_SEC="$(date --date "$1" +%s)" fi # Sottrae la data desiderata dalla data corrente e la converte in minuti OLDER=$ (($NOW_SEC-$ OLDER_SEC)) OLDER_MIN=$(($OLDER/60)) [ ! -d "$(TMP_PATH)/" ] && mkdir "$(TMP_PATH)/" [ -z "`grep "$( TMP_PATH)" /proc/ mounts`" ] && mount "$(VOLUME)" "$(TMP_PATH)/" -o "$(MOUNT_OPTS)" && ( # Mount mkdir "$(TMP_PATH)/$(NOW)/" # Crea istantanee btrfs subvol snap / "$(TMP_PATH)/$(NOW)/rootsnap" > /dev/null 2>&1 btrfs subvol snap /home "$(TMP_PATH)/$(NOW)/homesnap" > /dev/ null 2>&1 ) && ( # Cerca cartelle con istantanee precedenti alla data specificata per f in `find "$(TMP_PATH)" -mindepth 1 -maxdepth 1 -type d -cmin +"$OLDER_MIN" -print0 |xargs - 0`; esegui btrfs subvol del "$(f)/rootsnap" > /dev/null 2>&1 && btrfs subvol del "$(f)/homesnap" > /dev/null 2>&1 && # ed elimina gli snapshot e le cartelle che li contengono rmdir "$f" done ) umount -l "$(TMP_PATH)" && rmdir "$(TMP_PATH)"
Questo script può essere posizionato dove è conveniente (personalmente preferisco inserire tali cose in /usr/local/bin, ma questa è una questione di gusti), ed eseguirlo da cron o da rc.local. Per impostazione predefinita, lo script ruota le istantanee più vecchie di un giorno, ma puoi specificare qualsiasi numero desiderato nel formato del comando data - soprattutto, non dimenticare di racchiudere tra virgolette.
Per non estrarre il disco con l'ubunt registrato ogni volta che vengono danneggiati file vitali, è possibile aggiungere la voce di avvio dall'immagine ISO nel menu di Grub, cosa che propongo di fare. Per fare ciò, avrai bisogno di una partizione non Btrfs (perché per ragioni sconosciute, l'initramfs standard dell'ISO di Ubuntu non vuole vedere l'immagine se si trova sulla partizione con la FS descritta) e le mani dirette. Aggiungi le seguenti righe al file /etc/grub.d/40_custom:
Voce di menu "Ubuntu 12.10 i386 iso" ( insmod part_msdos insmod fat # Installa la root da cui otteniamo l'ISO set root="hd0,msdos7" # Percorso dell'immagine relativa al set di root precedente isofile=/ubuntu-12.10-desktop- i386.iso # Monta come dispositivo di loopback direttamente nel ciclo di loopback di Grub $isofile linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=$isofile noeject noprompt -- initrd (loop)/casper/initrd.lz )
ed esegui il comando per aggiornare la configurazione principale di Grub:
$ sudo aggiorna grub
Ora, anche in caso di gravi danni al sistema, a meno che, ovviamente, non siano interessati il bootloader e i suoi file, è sempre possibile eseguire l'avvio da un'immagine ISO e modificare i file danneggiati o tornare a uno stato di sistema precedente.
Se lavori in un ambiente chroot come root, allora c'è un'opportunità per scappare da lì. Un modo è usare la chiamata di sistema mknod() e quindi montare la vera radice. L'installazione del set di patch grsecurity risolve questo problema.
I comandi Btrfs hanno forme standard e abbreviate. Ad esempio, il comando "btrfs subvolume snapshot" può essere scritto come "btrfs su sn".
Quindi, supponiamo che tu abbia abbandonato il sistema e devi ripristinarlo da un'istantanea Btrfs. Per fare ciò, avvia da questa immagine ISO, monta la partizione su cui hai rilasciato il sistema, esattamente la partizione, non il sottovolume! - e inserisci i seguenti comandi (ovviamente adattati alle tue istantanee e partizioni):
# cd /mnt/sda11 # mv @ @_badroot # mv @snapshots/201302011434/rootsnap @
Lo stesso, se necessario, lo facciamo con @home e riavviamo. Se tutto è andato bene, puoi rimuovere @_badroot:
$ sudo btrfs subvol del @_badroot
Sui sistemi *nix, ci sono molti modi per proteggersi o mitigare i cattivi esperimenti. Ne ho recensiti alcuni. Tuttavia, vale la pena notare che tutti questi metodi sono destinati principalmente agli sperimentatori a cui piace scavare più a fondo nel sistema. Non sono adatti per rilevare malware: sono abbastanza facili da rilevare, sebbene forniscano sicuramente un certo livello di sicurezza.
btrfs(a volte pronunciato butter fs) è un nuovo file system gratuito sviluppato con il supporto di Oracle. Distribuito sotto licenza GPL. Nonostante il suo sviluppo sia ancora lungi dall'essere completo, il 9 gennaio 2009 il file system è stato integrato in Kernel Linux ed è disponibile in Debian Squeeze.
Sebbene Btrfs fosse incluso nel kernel 2.6.29, gli sviluppatori affermano che "a partire dal kernel 2.6.31, d'ora in poi prevediamo solo di rendere compatibile il formato di modifica del disco". Gli sviluppatori vogliono ancora migliorare gli strumenti utente/gestione per renderli più facili da usare. Per ottenere Informazioni aggiuntive su Btrfs, al link in sezione.
Ext2/3/4 può essere trasformato in Btrfs (ma non viceversa).
Debian Squeeze e le versioni più recenti supportano Btrfs.
btrfs-tools (in DebianSqueeze e superiori)
Vedi anche: Domande frequenti sul wiki di Btrfs
Creazione di un file system:
mkfs.btrfsGestire volumi, sottovolumi, snapshot; controllo dell'integrità del file system:
btrfsctlScansione per filesystem btrfs:
btrfsctl -a btrfsctl -A /dev/sda2Creazione di istantanee e sottovolumi:
mount -t btrfs -o subvol=. /dev/sda2 /mnt btrfsctl -s new_subvol_name /mnt btrfsctl -s snapshot_of_default /mnt/default btrfsctl -s snapshot_of_new_subvol /mnt/new_subvol_name btrfsctl -s snapshot_of_a_snapshot /mnt/snapshot_of_new_subvol ls /mntControllo degli extent tree del file system:
btrfsckMetadati di output in formato testo:
debug-tree debug-tree /dev/sda2 >& big_output_fileMostra i filesystem btrfs sul disco rigido:
btrfs-show /dev/sda*Defrag (non richiesto per impostazione predefinita):
# deframmentazione del filesystem btrfs /mnt o # deframmentazione del filesystem btrfs /mnt/file.isoIl file system ext3 può essere trasformato in btrfs e lavorare ulteriormente con esso come nuovo file system. Inoltre, lo stato del file system ext3 originale sarà disponibile in seguito.
# Esegui sempre fsck prima %# fsck.ext3 -f /dev/xxx # Converti da Ext3->Btrfs %# btrfs-convert /dev/xxx # Monta il filesystem Btrfs risultante %# mount -t btrfs /dev/xxx /btrfs # Monta l'istantanea ext3 %# mount -t btrfs -o subvol=ext2_saved /dev/xxx /ext2_saved # Loopback monta il file immagine %# mount -t ext3 -o loop,ro /ext2_saved/image /ext3La directory /ext3 ora mostra lo stato del file system originale.
Lo smontaggio avviene in ordine inverso:
%# umount /ext3 %# umount /ext2_saved %# umount /btrfsPuoi ripristinare un file system ext3 e perdere le modifiche:
%# btrfs-convert -r /dev/xxxOppure puoi rimanere su btrfs ed eliminare l'immagine del filesystem ext3 salvata:
%# rm /ext2_saved/imageNota: il nuovo file system a volte ha una dimensione dei metadati molto grande dopo la conversione.
Visualizza la dimensione dei metadati:
# btrfs filesystem df /mnt/data1tb/Normalizza le loro dimensioni:
btrfs saldo fi /mnt/btrfsUlteriori informazioni: conversione da ext3 (inglese) e conversione da ext3fs a btrfs (russo)
Per btrfs, è disponibile il ridimensionamento online (al volo) del file system. Per prima cosa devi montare sezione desiderata:
# mount -t btrfs /dev/xxx /mntAggiunta di 2 GB:
# btrfs filesystem resize +2G /mnt o # btrfsctl -r +2g /mntRidimensionamento di 4 GB:
# btrfs filesystem resize -4g /mnt o # btrfsctl -r -4g /mntImposta la dimensione su un file system da 20 GB:
# btrfsctl -r 20g /mnt o # btrfs filesystem resize 20g /mntUtilizzo di tutto lo spazio libero:
# btrfs filesystem resize max /mnt o # btrfsctl -r max /mntI comandi precedenti sono validi solo per il file system. Per ridimensionare una partizione, è necessario utilizzare altre utilità come fdisk. Considera un esempio per ridurre una partizione di 4 GB. Montare e ridurre la partizione:
# mount -t btrfs /dev/xxx /mnt # btrfsctl -r -4g /mntOra smonta la partizione e usa fdisk:
# umount /mnt fdisk /dev/xxx # dove si trova dev/xxx HDD con la sezione di cui abbiamo bisognoOriginale: come creare e utilizzare gli snapshot BTRFS - Tutorial
Autore: Igor Ljubuncic
Data di pubblicazione: 25 febbraio 2012
Traduzione: A. Krivoshey
Data del trasferimento: aprile 2012
BTRFS è un file system relativamente nuovo basato su ZFS di Sun, che ha apportato la massima innovazione a Unix negli ultimi 25 anni prima che fosse rilevato da Oracle. BTRFS è ancora considerato instabile e quindi non adatto per applicazioni di produzione. Tuttavia, questo file system ha molte funzioni utili che vale la pena esplorare. Uno di questi è la creazione di istantanee del sistema.
Fammi chiarire. Le istantanee sono istantanee istantanee dello stato di un sistema. In un certo senso, se copi un file e ne fai un backup, ne stai scattando un'istantanea al momento della copia. Questo può essere fatto ovunque e in qualsiasi momento. Pensa a un file system che può effettivamente gestire più copie dei tuoi file all'interno della sua struttura e lasciarti usare come preferisci. Sembra interessante, indaghiamo.
Prima di iniziare a scavare più a fondo, vorrei delineare brevemente le capacità di questo file system. BTRFS dovrebbe gestire tutte le operazioni di sistema relative ai dischi e alla gestione dei file, che di solito richiedono utilità aggiuntive. BTRFS fornisce deframmentazione, bilanciamento del carico, riduzione, espansione, hot swapping, RAID, istantanee, compressione, clonazione e altro ancora, tutto integrato nel driver del file system. Con altri file system, probabilmente avrai bisogno di una varietà di altri driver e utilità utente per gestire tutti questi tipi di operazioni, come una deframmentazione del file system, driver RAID e LVM e così via.
Funzionalità integrate significa prestazioni e facilità d'uso. Tuttavia, al momento BTRFS non è ancora completamente utilizzabile a causa dell'instabilità e del degrado delle prestazioni rispetto ad altri file system come Ext4. Ma ha un enorme potenziale, quindi non può essere ignorato, ma va studiato.
In questa guida, ti mostrerò come gestire gli snapshot. Questa è una funzionalità super rilevante che ti permetterà di creare backup file importanti prima di apportarvi qualsiasi modifica e quindi ripristinarli se necessario. In un certo senso, è come Ripristino configurazione di sistema di Windows più un driver di rollback a livello di filesystem. A proposito, oltre alle istantanee, in questo articolo puoi trovarne anche alcune informazioni utili sul lavoro quotidiano con il file system BTRFS. Il test è stato eseguito su un sistema Verne Fedora 16 con un desktop KDE.
È possibile utilizzare BTRFS per il file system root, ad eccezione di /boot, che deve essere formattato con un file system journaling tradizionale. Per semplicità, in questa guida lavoreremo con un dispositivo separato /dev/sdb1 formattato in BTRFS e utilizzato quando necessario. In pratica, potrebbe essere /home o /data o qualsiasi altra cosa.
Prenderemo /dev/sdb1 e lo monteremo. Quindi creeremo alcune sottosezioni. Pensa alle sottosezioni come alberi con radici virtuali, poiché ognuna di esse è una struttura di dati ad albero separata e indipendente, anche se i dati sono gli stessi.
Di seguito è riportata la sequenza dei comandi richiesti per questo. Non aver paura, ti spieghiamo come funzionano.
$ creazione sottovolume btrfs /mnt/data $ creazione sottovolume btrfs /mnt/data/orig $ echo "Dedoimedo is l33t" > /mnt/data/orig/file $ istantanea sottovolume btrfs /mnt/data/orig /mnt/data/backup
/dev/sdb1 è montato su /mnt. Creiamo una sottochiave chiamata data. Al suo interno, creiamo un'altra sottosezione chiamata orig. E già al suo interno verranno creati i nostri file. Dal punto di vista dell'utente, le sottosezioni sembrano normali directory. In altre parole, data e data/orig sono directory.
Successivamente, creiamo un file di testo in origine chiamato file contenente del testo. Infine, creiamo uno snapshot della sottochiave orig e lo chiamiamo backup. Ora abbiamo una copia identica della sottosezione orig. Ecco la prova:
Inoltre, per verificare, utilizziamo il comando elenco di sottovolumi btrfs per vedere tutte le sottosezioni:
Elenco dei sottovolumi $ btrfs
Si noti che ogni sottosezione ha il proprio numero ID. Come vedremo presto, questo è importante.
Attualmente, /mnt mostra sia orig che backup per impostazione predefinita (tutto nei dati). Possiamo cambiarlo. Ricordi che prima ho menzionato le strutture dell'albero radice virtuale? BTRFS consente di modificare la directory principale virtuale in una qualsiasi delle sottochiavi.
Pertanto, utilizzare sottosezioni e istantanee significa semplicemente passare da una gerarchia di dati all'altra. Non c'è bisogno di eliminare, sovrascrivere file o fare qualsiasi altra cosa. Devi solo passare a un'altra sottosezione. Vedremo ora come si fa.
Squadra btrfs subvolume set-ID predefinitoè tutto ciò di cui abbiamo bisogno. Imposteremo la visualizzazione predefinita su una partizione diversa, quindi smonteremo il dispositivo e lo rimonteremo. È importante!
Ora, se stai lavorando su un file system che non può essere smontato perché è in uso, come /usr o /etc, devi riavviare il computer affinché le modifiche abbiano effetto. Ora verrà visualizzata un'altra sottosezione nell'albero di directory specificato. L'utente non noterà la differenza, ma i dati nelle directory cambieranno.
Per vedere davvero come funziona, modificheremo il file file nel backup. Sostituire il testo Dedoimedo è l33t con Dedoimedo NON è l33t.
$ echo "Dedoimedo NON è l33t" > /mnt/data/backup/file
Ok, conosciamo l'ID di tutte le sottosezioni. Pertanto, monteremo l'ID come visualizzazione predefinita. Ciò significa che non appena rimonterai /mnt, qui vedremo un file con questo contenuto.
$ btrfs sottovolume set-default 257 /mnt $ umount /mnt $ mount /dev/sdb1 /mnt
Ora rimettiamo tutto a posto:
Questo può essere fatto tutte le volte che è necessario:
.png)
Sopra, abbiamo cambiato la vista tra 257 e 260, cioè tra orig e backup, di conseguenza, potremmo visualizzare il contenuto del file modificato. Abbiamo semplicemente mostrato all'utente diverse sottosezioni.
Di conseguenza, se vogliamo vedere sia orig che backup nella directory dei dati, dobbiamo ripristinare la visualizzazione predefinita della sottosezione di primo livello, ovvero i dati. Si noti che tutti i dati vengono visualizzati nella directory /mnt, poiché l'abbiamo scelta come punto di montaggio. Tuttavia, puoi utilizzare qualsiasi altra directory.
La funzione snapshot in BTRFS è implementata in modo abbastanza ordinato e il suo utilizzo non è difficile. Ovviamente, devi stare attento a usare l'albero dei dati corretto e non confondere le cose. Ma ora conosci già i comandi BTRFS di base e puoi agire con maggiore sicurezza. In futuro testeremo Snapper, un frontend BTRFS disponibile da openSUSE che consente di implementare la stessa funzionalità tramite un'interfaccia utente grafica per coloro a cui non piace la riga di comando.
Da smanettone, ho ancora l'abitudine di sperimentare costantemente con il sistema: ricostruzione, installazione di kernel RC non stabili, inclusi rami di aggiornamento sperimentali. Spesso direi persino che rompo il sistema troppo spesso (il mio record personale, 2 settimane senza reinstallare).
Cosa significa rompere? Quando qualcosa funziona molto male, ad esempio LibreOffice e Compiz che spesso si arrestano in modo anomalo e si bloccano, provo a riconfigurare il sistema, ma è piuttosto lungo e noioso.
Esattamente quello a cui sto arrivando.
Se a qualcuno, come me, piace sperimentare il sistema ed è stanco di ripristinarlo ogni volta, ecco un'opzione per te come ho risolto questo problema da solo. Passerò sotto il gatto.
How-to o bici normale.
E incolla qualcosa del genere lì, dopo i commenti:
menuentry "Ubuntu 12.10 amd64" ( set isofile=/ubuntu-12.10-desktop-amd64.iso loopback loop $isofile linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=$isofile noeject noprompt -- initrd (loop )/casper/initrd.lz )
In realtà è stato configurato a immagine e somiglianza (wiki ubuntu ufficiale):
/Grub2/ISOBoot
Ora "quasi" la cosa più importante, rigeneriamo la configurazione:
sudo update-grub
Tutto, ora dopo il riavvio, tenendo premuto il tasto Maiusc, possiamo avviare il mini sistema con Internet e GUI, indipendentemente dallo stato del sistema sottostante.
Un piccolo background:
Inizialmente era previsto di eseguire lo script tramite rc.local, ma non è stato eseguito, quindi è stato implementato tramite daily cron, in seguito ho sconfitto rc.local e disattivato gli snapshot all'inferno in cron.
Codice script:
#!/bin/bash #Questo script per la creazione automatica di istantanee all'avvio #Versione 1.2.9 set -e DATA="$(date +%g%m%d%k%M%S)" VOLUME=/dev/sda1 [ ! -d "/tmp/$DATI/" ] && sudo mkdir "/tmp/$DATI/" mount $VOLUME "/tmp/$DATI/" && ( [ ! -d "/tmp/$DATI/snapshots/" ] && sudo mkdir "/tmp/$DATA/snapshots/" mkdir "/tmp/$DATA/snapshots/$DATA/" && cd "/tmp/$DATA/" istantanea del sottovolume btrfs ./@ ."/snapshots/$DATA /@_$(DATI)/" btrfs subvolume snapshot ./@home ."/snapshots/$DATA/@home_$(DATA)/" [ ! -f ./snapshots/snapshots.log ] && touch ./snapshots/ snapshots.log chmod 777 ./snapshots/snapshots.log echo on_startup_$(date +%X_%x) >> ./snapshots/snapshots.log umount -l "/tmp/$DATA/" && sudo rmdir "/tmp/ $DATI/" )
Si trova in /etc/btrfs_snapshot_onstartup
Aggiungilo a /etc/rc.local e dai i permessi di esecuzione a entrambi i file tramite sudo chmod +x "file path"
La registrazione dell'esecuzione nel file ./snapshots/snapshots.log potrebbe non funzionare, quindi è necessario crearla manualmente con i diritti di root. Dopo il riavvio, lui stesso riceverà i diritti necessari.
In qualsiasi momento, possiamo visualizzare lo stato degli snapshot di sistema digitando:
cat /var/log/snapshots.log
Tutte le istantanee vengono aggiunte alla partizione con il sistema nella cartella delle istantanee, dove viene creata una cartella per ogni avvio riuscito del sistema.
Qualcuno potrebbe dire che non conviene scattare istantanee all'avvio. Niente affatto, giustifica, in un giorno posso apportare un sacco di modifiche al sistema e riavviarlo cento volte, e in casi alternativi non potrò tornare al momento di un lancio riuscito (effettivo), ma solo un giorno fa.
Opzione per l'avvio manuale:
#!/bin/bash #Questo script per la creazione automatica di istantanee #Versione 1.2.8 set -e DATA=$(date +%g%m%d%k%M%S) ########## ############################################################## -d /tmp/$DATA/ ] && sudo mkdir /tmp/$DATA/ sudo mount /dev/sda2 /tmp/$DATA/ && ( ################## #################################################### # [ ! -d /tmp/$DATA/snapshots/ ] && mkdir /tmp/$DATA/snapshots/ mkdir /tmp/$DATA/snapshots/$DATA/ cd /tmp/$DATA/ sudo btrfs subvolume snapshot ./@ . /snapshots/$DATA/@_$(DATA)/ sudo btrfs subvolume snapshot ./@home ./snapshots/$DATA/@home_$(DATA)/ ############## ################################################### ## ### sudo chmod 777 ./snapshots/snapshots.log sudo echo this.hands_$(date +%X_%x) >> ./snapshots/snapshots.log sudo cat ./snapshots/snapshots.log sleep 1 sudo umount - l /tmp/$DATA/ && sudo rmdir /tmp/$DATA/ ################################ # #################################### sudo btrfs filesystem df / #informazioni su fs ) read exit 0
Inoltre, le istantanee consentono non solo di tornare a un determinato stato del sistema, ma anche di estrarre da esso il file o la configurazione necessari, il che offre anche una certa libertà durante l'eliminazione di file di origine sconosciuta.
#!/bin/bash #Versione 0.0.9 set -e DATA=$(data +%g%m%d%k%M%S) [ ! -d "/tmp/$DATA" ] && sudo mkdir "/tmp/$DATA" sudo mount /dev/sda1 "/tmp/$DATA" && ( cd "/tmp/$DATA/snapshots/" for i in * /* do sudo btrfs subvolume delete "$i" done for i in * do sudo rmdir -v "$i" done echo cleanup_$(date +%g%m%d%k%M%S) > "./snapshots .log" sudo cp "./snapshots.log" "/var/log/snapshots.log" sudo umount -l "/tmp/$DATA" && sudo rmdir "/tmp/$DATA" ) read exit 0
Sarebbe anche bello finire lo script di pulizia in modo che ripulisse tutte le istantanee più vecchie di, ad esempio, settimane, e non tutte quelle disponibili, ci ho provato onestamente, ma non ha funzionato per me. Quindi potrebbe anche essere guidato, ad esempio, in cron per impostazione predefinita, per essere eseguito una volta al giorno, e quindi incluso nello script di installazione btrfs ufficiale, penso che con piccole modifiche, questa sia una soluzione abbastanza universale, basata su caratteristiche standard btrfs.
Sì, conosco lvm, ma non ho bisogno di un ulteriore livello di astrazione dall'hardware e anche mettere le immagini in una sezione separata non è comme il faut.
AGGIORNAMENTO 1:
Grazie agli utenti
Passare a un nuovo file system è sempre un compito difficile. Ci fidiamo già del vecchio e collaudato file system. Potrebbe anche avere alcune limitazioni in termini di funzionalità e prestazioni, ma non ci ha mai deluso. I nuovi file system offrono molto un gran numero di funzioni, ma sorge la domanda, ci si può fidare?
Uno di questi file system è Btrfs. Questo è un file system relativamente nuovo che è apparso nel 2007 ed è stato sviluppato da Oracle. Offre una gamma molto ampia di nuove funzionalità ed è quindi di grande interesse per gli utenti, ma circolano ancora voci in rete secondo cui questo file system non è ancora adatto per un uso permanente. In questo articolo cercheremo di capire quali opportunità ci offre Btrfs e anche se può già essere utilizzato.
Come ho detto, Btrfs è stato sviluppato da Oracle nel 2007. Non esiste un'unica decodifica del nome, alcuni dicono che significhi B-tree FS, altri Better Fs. Proprio come in altri file system, tutti i dati vengono archiviati su disco a indirizzi specifici. Questi indirizzi sono memorizzati nei metadati. Ed è qui che iniziano le differenze. Tutti i metadati sono organizzati come b-tree. Ciò offre prestazioni migliori quando si lavora con il file system e consente inoltre di aggiungere un numero illimitato di file.
Ma anche questo non è tutto. Quando si sovrascrive un file, i dati non vengono sovrascritti, ma solo la parte modificata viene copiata nella nuova posizione, quindi i metadati vengono semplicemente aggiornati. Ciò consente di creare istantanee del file system che non occupano spazio su disco fino a quando non sono state apportate molte modifiche. Se il vecchio blocco non è più necessario perché non fa parte di nessuno snapshot, viene eliminato automaticamente.
Grazie alla sua struttura, Btrfs ha molte possibilità, ad esempio può gestire i supporti di archiviazione molto grandi di oggi. La dimensione massima del file system è di 16 exabyte. Tutto questo è possibile grazie al corretto utilizzo dello spazio su disco. Altri file system utilizzano l'intero disco rigido, end-to-end, per registrare la loro struttura.
Btrfs fa le cose in modo diverso. Ogni disco, indipendentemente dalle sue dimensioni, è suddiviso in blocchi da 1 GB per i dati e 256 MB per i metadati. Questi blocchi vengono quindi assemblati in gruppi, ognuno dei quali può essere memorizzato diversi dispositivi, il numero di tali blocchi in un gruppo può dipendere da livello RAID per il gruppo. Il gestore del volume è già integrato nel file system, quindi non è necessario utilizzare software aggiuntivo.
La protezione e la compressione dei dati sono supportate anche a livello di file system, quindi anche qui non sono necessari programmi aggiuntivi. Il file system btrfs supporta anche il mirroring dei dati su più supporti. Ecco altre caratteristiche di btrfs che possono essere menzionate:
Tutto questo è molto buono, ma è già possibile utilizzare questo file system? Proviamo ad affrontare questo.
Ci sono ancora molte idee sbagliate intorno a Btrfs. Molti di loro derivano da problemi reali che erano all'inizio dello sviluppo del file system. Ma le persone che guardano queste informazioni non guardano la data. Sì, Btrfs era davvero instabile e instabile. Ci sono stati molti problemi di perdita di dati e molti utenti ne hanno scritto, ma era nel 2010.
La parte più importante di un file system è il suo formato di archiviazione su disco. Ma il formato del file system Btrfs è già fisso, è successo nel 2012 e non cambia più se non assolutamente necessario. Questo da solo è sufficiente per riconoscere la stabilità di btrfs.
Ma perché Btrfs è considerato instabile da molti? Ci sono diverse ragioni per questo. Innanzitutto, è la paura degli utenti verso le nuove tecnologie. Questo non era solo in Linux, ma anche in Microsoft, con la loro transizione a NTFS, e in Apple. Ma c'è un paradosso qui, il file system XFS ha attraversato 20 anni di sviluppo stabile, ma il file system più stabile è ext4, che è stato sviluppato da un fork di ext3 nel 2006. In effetti, è un anno più vecchio di Btrfs.
Il secondo motivo è in fase di sviluppo attivo, sebbene il formato di archiviazione dei dati sia congelato, la base di codice principale è ancora attivamente sviluppata e c'è ancora molto spazio per miglioramenti delle prestazioni e nuove funzionalità.
Ma ci sono già molte conferme che il file system è pronto. Questo file system viene utilizzato sui server di Facebook, dove l'azienda memorizza i suoi dati sensibili. E questo di per sé è un fattore importante. Aziende come Facebook, SuSE, RedHat, Oracle, Intel e altre stanno lavorando per migliorare il file system. Questo file system è stato utilizzato per impostazione predefinita in SUSE Linux Enterprise dalla versione 12. Tutti questi fattori insieme dimostrano che il file system è abbastanza pronto per l'uso. E date le funzionalità e le caratteristiche di btrfs, può già essere utilizzato.
Perché vale la pena usare Btrfs e se ne vale la pena, capito. Ora vorrei mostrare un po' di pratica in modo da poter valutare questo file system in azione. Darò esempi basati su Ubuntu. Innanzitutto, installa gli strumenti di gestione del file system:
sudo apt install btrfs-tools
Per prima cosa devi creare un file system. Diciamo che ne abbiamo due dischi fissi/dev/sdb e /dev/sdc, vogliamo creare un singolo file system su di essi con il mirroring dei dati. Per fare questo, basta fare:
sudo mkfs.btrfs /dev/sdb /dev/sdc
L'impostazione predefinita sarà RAID0 per i dati (nessuna ridondanza e RAID1 per i metadati (duplicati su un singolo disco). Quando si utilizza un singolo disco, anche i metadati vengono duplicati, se si desidera disabilitare questo comportamento, è possibile utilizzare -m single opzione:
sudo mkfs.btrfs -m singolo /dev/sdb
Ma così facendo, aumenti il rischio di perdita di dati, perché se i metadati vengono persi, lo sono anche i dati.
È possibile visualizzare le informazioni sul file system appena creato con il comando:
sudo btrfs filesystem mostra /dev/sdb
O su tutti i filesystem montati:
mostra il file system sudo btrfs
Per montare, usa il solito comando:
sudo mount /dev/sdb /mnt
Puoi montare qualsiasi unità, avrà lo stesso effetto. La riga in /etc/fstab sarà simile a questa:
/dev/sdb /mnt btrfs predefinito 0 1
Ora esaminiamo le informazioni sullo spazio su disco occupato:
sudo btrfs filesystem df /mnt
Per abilitare la compressione, basta aggiungere l'opzione compress durante il montaggio. Puoi passare l'algoritmo lzo o zlib ad esso:
sudo mount -o compress=lzo /dev/sdb /mnt
$ sudo mount -o compress=zlib /dev/sdb /mnt
Per ripristinare un Btrfs danneggiato, utilizzare l'opzione di montaggio di ripristino:
sudo mount -o recovery /dev/sdb /mnt
Puoi ridimensionare un volume in tempo reale usando il comando di ridimensionamento:
sudo btrfs filesystem ridimensiona -2g /mnt
Ridurre le dimensioni di 2 gigabyte. Quindi aumentare di 1 gigabyte:
sudo btrfs filesystem ridimensiona +1g /mnt
Puoi creare partizioni logiche, sottovolumi all'interno della partizione principale usando Btrfs. Possono essere montati all'interno della partizione principale:
sudo btrfs sottovolume crea /mnt/sv1
$ sudo btrfs sottovolume crea /mnt/sv2
$ elenco di sottovolumi sudo btrfs /mnt
Puoi montare il sottovolume con l'id che hai ottenuto con l'ultimo comando:
sudo umount /dev/sdb
sudo mount -o subvolid=258 /dev/sdb /mnt
Oppure puoi usare il nome:
sudo mount -o subvol=sv1 /dev/sdb /mnt
Innanzitutto, monta la radice btrfs invece del sottovolume:
sudo umount /mnt
sudo mount /dev/sdb /mnt/
Per rimuovere un volume secondario, puoi utilizzare il percorso di montaggio, ad esempio:
sudo btrfs sottovolume cancella /mnt/sv1/
Sistema di file Btrfs ti consente di creare istantanee delle modifiche. Il comando snapshot viene utilizzato per questo. Ad esempio, creiamo un file, quindi acquisiamo un'istantanea:
tocca /mnt/sv1/test1 /mnt/sv1/test2
Crea un'istantanea:
sudo btrfs snapshot del sottovolume /mnt/sv1 /mnt/sv1_snapshot
