Open Source im professionellen Einsatz
Linux-Magazin 04/2013
© Jane Rix, 123RF.com

© Jane Rix, 123RF.com

Alten Flashspeicher als Backupmedium nutzen

USB-Stickereien

USB-Sticks und SD-Karten verlieren schnell an Wert. Verteilt ein Skript Daten auf mehrere solcher Speicher, taugen Flashspeicher trotz begrenzter Kapazität als schnelle und zudem stoßsichere Backupmedien.

915

Es scheint, als ob auch USB-Sticks und SD-Karten dem Mooreschen Gesetz folgen, da sich die Kapazität angebotener Speicher jedes Jahr verdoppelt. Ein Stick mit 64 GByte kostet heute 40 US-Dollar, und ein vor Jahren führender 8-GByte-Stick hat fast allen Wert verloren und landet in der Schublade. Am anderen Ende des Produktspektrums steigen die Preise dagegen überproportional: Kostet ein 128-GByte-Stick etwa 80 Dollar, schlägt die doppelte Kapazität, 256 GByte, mit dem vierfachen Preis zu Buche.

Mehrere Einzelspeicher zu kombinieren würde akzeptable Kapazitäten zu einem niedrigen Preis bedeuten. Um mehrere Speicherbausteine zu einem Verbund zusammenzuschließen, böte sich eine Softwarelösung wie der Linux Volume Manager (LVM) an, der Hardware- elegant und zuverlässig zu Softwarepartitionen zusammenschweißt, die sich auf der Applikationsebene dann exakt wie ihre in Metall und Plastik gegossenen Hardwarelösungen anfühlen.

Abbildung 1: Verschieden große USB-Sticks und SD-Karten dienen kombiniert als Speichermedium.

Online PLUS

In einem Screencast demonstriert Michael Schilli das Beispiel: http://http://www.linux-magazin.de/plus/2013/04http://]

Rucksackproblem

Allerdings will wohl kaum jemand die USB-Ports seines Rechners jedes Mal mit einer ganzen Handvoll USB-Sticks akupunktieren, nur um eine LVM-Partition zu mounten, die Zugriff auf ein Backup bietet. Besser wäre es, einzelne Dateien auf die Sticks zu verteilen. Die Literatur beschreibt das Verfahren als Rucksackproblem [2]. In dieser Optimierungsaufgabe der Kombinatorik gilt es, verschieden schwere Gegenstände in Rucksäcke zu verpacken, von denen keiner sein spezifisches Höchstgewicht überschreiten darf.

Dem Gewicht eines Gegenstands entspricht beim Backup die Größe einer Datei in Bytes. Der Rucksack ist der USB-Stick, der eine Reihe dieser Dateien speichert. Da sich das Problem der Klasse NP-vollständig (nicht-deterministisch polynominell vollständig, [3]) zuordnen lässt, ist es nachweisbar unökonomisch, die optimale Verteilung der Gegenstände zu finden. Bei den USB-Sticks spielen ein paar verschenkte Bytes jedoch keine Rolle, und ein simpler Algorithmus darf die "Behälter" einfach der Reihe nach befüllen, bis sie voll sind, und dann jeweils zum nächsten freien übergehen (Abbildung 2).

Abbildung 2: Der Rucksackalgorithmus füllt einen Behälter vollständig und schreitet dann zum nächsten.

Wie groß die einzelnen Behälter sind, hängt von der Größe der verwendeten USB-Sticks ab, die oft unterschiedliche Speicherkapazitäten aufweisen. Die Yaml-Datei ein Listing 1 gibt daher vor, wie die Sticks heißen und wie viele Bytes sie fassen können. Im Beispiel nummeriert die Datei die Sticks einfach durch. Mit einem Etikettendrucker lassen sich die Sticks im Verbund prima beschriften.

Listing 1

usbback.yml

01 -
02   name: 1
03   size: 4g
04
05 -
06   name: 2
07   size: 8g
08
09 -
10   name: 3
11   size: 4g

Gilt es zum Beispiel, PDF-Dateien in einem Verzeichnis auf USB-Sticks zu verteilen, legt das Skript in Listing 2 zunächst ein neues Verzeichnis an und weist ihm gemäß der Yaml-Datei eine Byte-Kapazität zu. Dann füllt es den Behälter, indem es symbolische Links im Zielverzeichnis anlegt, die auf die Dateien im Originalverzeichnis zeigen, und zählt mit, wie viele Bytes symbolisch im Rucksack liegen, obwohl der Symlink natürlich kaum Speicher verbraucht.

Ist der Rucksack voll, legt das Skript gemäß der Konfiguration in Listing 1 einen neuen an und setzt das Verfahren fort, bis es keine Dateien mehr findet oder die definierten Behälter verbraucht sind. Die Symlinks verbleiben auch nach dem Skriptlauf in den Zielverzeichnissen und geben Auskunft darüber, welche Originaldateien schon gesichert sind.

Listing 2

usbback

01 #!/usr/local/bin/perl -w
02 use strict;
03 use local::lib;
04 use YAML qw( LoadFile );
05 use Algorithm::Bucketizer 0.13;
06 use File::Basename;
07 use Sysadm::Install qw( :all );
08 use Log::Log4perl qw(:easy);
09
10 Log::Log4perl->easy_init($DEBUG);
11
12 my( $home )  = glob "~";
13 my $src_dir  = "$home/books";
14 my $dst_dir  = "$home/sticks";
15 my $cfg_file = "usbback.yml";
16 my $gig      = 1_000_000_000;
17 my $buckets = Algorithm::Bucketizer->new();
18
19 my $conf = LoadFile $cfg_file;
20
21 my %files = ();
22
23 for my $path ( <$src_dir/*> ) {
24   my $file = basename $path;
25   $files{ $file } =
26     blocksize_round( -s $path );
27 }
28
29   # buckets configured in YAML
30 for my $entry ( @$conf ) {
31   my $bucket_dir  = $entry->{ name };
32   my $bucket_path = "$dst_dir/$bucket_dir";
33
34   if( !-d $bucket_path ) {
35     mkd $bucket_path;
36   }
37   if( $entry->{ size } =~ /(\d+)g/ ) {
38       $entry->{ size } = $1 * $gig;
39   }
40
41   my $bucket = $buckets->add_bucket(
42       maxsize => $entry->{ size },
43       dir     => $bucket_path,
44   );
45
46     # prefill buckets with links found
47   for my $path ( <$bucket_path/*> ) {
48     my $file = basename $path;
49     my $ref  = readlink $path;
50     my $size = blocksize_round( -s $ref );
51
52     $buckets->prefill_bucket(
53         $bucket->idx(), $file, $size );
54
55     delete $files{ $file };
56   }
57 }
58
59   # remaining files
60 for my $file ( sort keys %files ) {
61   my $size = $files{ $file };
62
63   my $bucket = $buckets->add_item(
64       $file, $size ) or
65         die "Item $file won't fit, " .
66         "buckets are full";
67
68   INFO "Adding $file ($size bytes) to ",
69     "bucket $bucket->{ dir }";
70
71   symlink "$src_dir/$file",
72           "$bucket->{ dir }/$file";
73 }
74
75 ###########################################
76 sub blocksize_round {
77 ###########################################
78   my( $size ) = @_;
79
80   my $bs = 4096;
81
82   if( ($size % $bs) ) {
83       return (int( $size/$bs ) + 1 ) * $bs;
84   }
85
86   return $size;
87 }

Konstanz spart Arbeit

Bei einem erneuten Backuplauf stellt das Skript fest, welcher Rucksack schon mit welchen Dateien gefüllt ist, und sucht für noch nicht gesicherte Dateien im Originalverzeichnis aufnahmefähige Behälter. Das hat den Vorteil, dass der User bereits gefüllte USB-Speichersticks nicht bei jedem Backuplauf neu einstecken und auffrischen muss. Die Daten darauf haben sich ja nicht geändert. Der Einfachheit halber geht der Algorithmus davon aus, dass nur neue Dateien ins Originalverzeichnis kommen, wie das etwa bei einer E-Book-Bibliothek mit PDF-Dateien oder einer Musiksammlung der Fall ist.

Diesen Artikel als PDF kaufen

Express-Kauf als PDF

Umfang: 3 Heftseiten

Preis € 0,99
(inkl. 19% MwSt.)

Linux-Magazin kaufen

Einzelne Ausgabe
 
Abonnements
 
TABLET & SMARTPHONE APPS
Bald erhältlich
Get it on Google Play

Deutschland

Ähnliche Artikel

  • Duplicity

    Wer wertvolle Daten archiviert oder sichert, sollte sich eine Strategie zurechtlegen, die auch deren Sicherheit berücksichtigt. Die Backupsoftware Duplicity erlaubt das Archivieren verschlüsselter Daten auf unsicherem Terrain.

  • Überall Musik

    Das Modul Apache::MP3 baut eine komfortable Web-Jukebox um lose MP3-Sammlungen. Ein zusätzliches Perl-Skript macht die Songauswahl für den Musikliebhaber noch komfortabler.

  • Riak CS

    Amazons Onlinestorage-API S3 kann man auch ohne den Internetkonzern verwenden: Das freie Riak CS baut auf einer verteilten Datenbank auf und bringt flexiblen Cloudspeicher auf die eigenen Server.

  • Übersichtliche Verkehrsregelung

    Seit Kernel 2.2 beherrscht Linux Bandbreitenkontrolle. Der dafür zuständige Befehl »tc« ist nur für Eingeweihte verständlich. TCng implementiert eine einfache C-ähnliche Sprache, um Traffic Control übersichtlicher und leichter zu konfigurieren und bei Bedarf Verkehrsstaus für Testzwecke zu simulieren.

  • Hashfunktionen

    Hashfunktionen sind aus der Informatik nicht mehr wegzudenken. Sie spielen nicht nur in Datenbanken oder beim Berechnen von Prüfsummen eine Rolle, sondern sind unverzichtbar, wenn es um das sichere Aufbewahren von Passwörtern gilt.

comments powered by Disqus

Ausgabe 09/2016

Digitale Ausgabe: Preis € 6,40
(inkl. 19% MwSt.)

Artikelserien und interessante Workshops aus dem Magazin können Sie hier als Bundle erwerben.