Inhaltsverzeichnis
Hier werden Werkzeuge und Tipps zur Verwaltung von Binär- und Textdateien auf einem Debian-System beschrieben.
![]() |
Warnung |
---|---|
Nicht-koordinierte zeitgleiche Schreibzugriffe auf Geräte und Dateien durch mehrere Prozesse sind nicht erlaubt, da dadurch eine Race Condition (Wettlaufsituation um konkurrierende Zugriffe auf die Ressource) entstehen könnte. Dies kann über einen File locking-Mechanismus mittels flock(1) umgangen werden. |
Die Sicherheit der Daten und deren kontrolliertes Austauschen mit anderen hat verschiedene Aspekte:
Erzeugung von Datenarchiven;
Fern-Speicherzugriff;
Vervielfältigung;
Nachverfolgung der Änderungshistorie;
Erleichterung des Tauschens von Daten;
Verhinderung von unerlaubten Dateizugriffen;
Erkennung von unerlaubten Dateiveränderungen.
Diese können über die Verwendung einer Kombination von Werkzeugen realisiert werden:
Archivierungs- und Kompressionswerkzeuge
Kopier- und Synchronisationswerkzeuge
Netzwerk-Dateisysteme;
Wechseldatenträger;
Secure Shell;
Authentifizierungssysteme;
Versionskontrollsysteme;
Hash- und kryptographische Verschlüsselungswerkzeuge.
Hier eine Zusammenfassung von Archivierungs- und Kompressionswerkzeugen im Debian-System:
Tabelle 10.1. Liste von Archivierungs- und Kompressionswerkzeugen
Paket | Popcon | Größe | Erweiterung | Befehl | Erläuterung |
---|---|---|---|---|---|
tar
|
V:907, I:999 | 2770 |
.tar
|
tar(1) | Standard-Archivierungs-Programm (De-Facto-Standard) |
cpio
|
V:365, I:999 | 989 |
.cpio
|
cpio(1) | Unix-Archivier-Programm im System-V-Stil, zu verwenden mit find(1) |
binutils
|
V:201, I:699 | 90 |
.ar
|
ar(1) | Archivier-Programm zur Erstellung von statischen Bibliotheken |
fastjar
|
V:5, I:51 | 172 |
.jar
|
fastjar(1) | Archivier-Programm für Java (zip-artig) |
pax
|
V:15, I:42 | 175 |
.pax
|
pax(1) |
neues POSIX-Archivier-Programm, Kompromiss zwischen tar
und cpio
|
gzip
|
V:876, I:999 | 231 |
.gz
|
gzip(1), zcat(1), … | GNU LZ77-Kompressionswerkzeug (De-Facto-Standard) |
bzip2
|
V:196, I:946 | 184 |
.bz2
|
bzip2(1), bzcat(1), … | Burrows-Wheeler
Block-Sorting Kompressions-Werkzeug mit höherem
Kompressionsverhältnis als
gzip(1)
(langsamer als gzip mit ähnlicher Syntax)
|
lzma
|
V:4, I:48 | 141 |
.lzma
|
lzma(1) | LZMA-Kompressionswerkzeug mit höherem Kompressionsverhältnis als gzip(1) (überholt) |
xz-utils
|
V:441, I:958 | 515 |
.xz
|
xz(1), xzdec(1), … | XZ-Kompressionswerkzeug mit höherem
Kompressionsverhältnis als
bzip2(1)
(langsamer als gzip , aber schneller als
bzip2 ; ersetzt das LZMA-Kompressionswerkzeug)
|
p7zip
|
V:78, I:385 | 986 |
.7z
|
7zr(1), p7zip(1) | 7-Zip-Dateiarchivier-Programm mit hohem Kompressionsverhältnis (LZMA-Kompression) |
p7zip-full
|
V:143, I:531 | 4659 |
.7z
|
7z(1), 7za(1) | 7-Zip-Dateiarchivier-Programm mit hohem Kompressionsverhältnis (LZMA- und andere Kompressionsalgorithmen) |
lzop
|
V:6, I:48 | 97 |
.lzo
|
lzop(1) | LZO-Kompressionswerkzeug mit höherer
Kompressions- und Dekompressionsgeschwindigkeit als
gzip(1)
(niedrigeres Kompressionsverhältnis als gzip mit
ähnlicher Syntax)
|
zip
|
V:52, I:432 | 608 |
.zip
|
zip(1) | InfoZIP: DOS-Archivierungs- und Kompressionswerkzeug |
unzip
|
V:290, I:803 | 534 |
.zip
|
unzip(1) | InfoZIP: DOS-Dearchivierungs- und Dekompressionswerkzeug |
![]() |
Warnung |
---|---|
Setzen Sie nicht die " |
![]() |
Anmerkung |
---|---|
Ein gezipptes
tar(1)-Archiv
verwendet die Dateierweiterung " |
![]() |
Anmerkung |
---|---|
Ein xz-komprimiertes
tar(1)-Archiv
verwendet die Dateierweiterung " |
![]() |
Anmerkung |
---|---|
Die Popularität der Kompressionsmethoden in FOSS-Programmen wie
tar(1)
hat sich mit der Zeit wie folgt verschoben: |
![]() |
Anmerkung |
---|---|
cp(1), scp(1) und tar(1) könnten Einschränkungen bei speziellen Dateien haben. cpio(1) ist dabei erheblich vielseitiger. |
![]() |
Anmerkung |
---|---|
cpio(1) wurde entwickelt, um zusammen mit find(1) und anderen Befehlen verwendet zu werden und ist geeignet, Backup-Skripte zu erstellen, da der Teil des Skriptes zur Dateiauswahl eigenständig getestet werden kann. |
![]() |
Anmerkung |
---|---|
Die interne Struktur von Libreoffice-Dateien entspricht der von
" |
![]() |
Anmerkung |
---|---|
Das de-facto plattform-übergreifende Archivwerkzeug ist
|
Hier eine Zusammenfassung von einfachen Kopier- und Backup-Werkzeugen im Debian-System:
Tabelle 10.2. Liste von Kopier- und Synchronisationswerkzeugen
Paket | Popcon | Größe | Werkzeug | Funktion |
---|---|---|---|---|
coreutils
|
V:878, I:999 | 15016 | GNU cp |
Dateien und Verzeichnisse lokal kopieren (verwenden Sie
"-a " für rekursive Operationen)
|
openssh-client
|
V:821, I:996 | 4151 | scp |
Dateien und Verzeichnisse von fern kopieren (Client, verwenden Sie
"-r " für rekursive Operationen)
|
openssh-server
|
V:680, I:802 | 873 | sshd | Dateien und Verzeichnisse von fern kopieren (ferner Server) |
rsync
|
V:269, I:602 | 691 | - | 1-Weg-Synchronisation und -Backup von fern |
unison
|
V:4, I:19 | 3452 | - | 2-Wege-Synchronisation und -Backup von fern |
Das Kopieren von Dateien mit rsync(8) bietet mehr Funktionalitäten als mit anderen Werkzeugen:
Delta-Transfer-Algorithmus, der nur die Unterschiede zwischen Quelle und Ziel überträgt;
schneller Prüf-Algorithmus, der (standardmäßig) nach Dateien sucht, die sich in Größe oder Änderungs-Zeitstempel verändert haben;
die Optionen "--exclude
" und
"--exclude-from
", vergleichbar mit denen von
tar(1);
die Syntax des Schrägstrichs hinter dem Quellverzeichnis, die verhindert, dass eine zusätzliche Verzeichnisebene auf dem Zielort erstellt wird.
![]() |
Tipp |
---|---|
Die Nutzung des in Abschnitt 10.2.3, „Ein Kopierskript für die Datensicherung“
erwähnten Skripts für statische Datenarchive sollte mit der Option
" |
![]() |
Tipp |
---|---|
Versionskontrollsysteme (VCS) wie die in Tabelle 10.11, „Liste von Werkzeugen für die Versionskontrolle“ können ebenfalls als Mehrwege-Kopier- und Synchronisationswerkzeuge dienen. |
Hier finden Sie mehrere Wege, um den kompletten Inhalt des Verzeichnisses
"./source
" mit verschiedenen Werkzeugen zu archivieren
oder dearchivieren.
GNU tar(1):
$ tar -cvJf archive.tar.xz ./source $ tar -xvJf archive.tar.xz
Alternativ auch:
$ find ./source -xdev -print0 | tar -cvJf archive.tar.xz --null -F -
cpio(1):
$ find ./source -xdev -print0 | cpio -ov --null > archive.cpio; xz archive.cpio $ zcat archive.cpio.xz | cpio -i
Hier finden Sie mehrere Wege, um den kompletten Inhalt des Verzeichnisses
"./source
" mit verschiedenen Werkzeugen zu kopieren.
Lokale Kopie: "./source
"-Verzeichnis →
"/dest
"-Verzeichnis
Kopie auf einen fernen Rechner: "./source
"-Verzeichnis
auf dem lokalen Rechner → "/dest
"-Verzeichnis auf dem
Rechner "user@host.dom
"
rsync(8):
# cd ./source; rsync -aHAXSv . /dest # cd ./source; rsync -aHAXSv . user@host.dom:/dest
Sie können auch die Syntax mit Schrägstrich am Ende des Zielverzeichnisses nutzen:
# rsync -aHAXSv ./source/ /dest # rsync -aHAXSv ./source/ user@host.dom:/dest
Alternativ auch:
# cd ./source; find . -print0 | rsync -aHAXSv0 --files-from=- . /dest # cd ./source; find . -print0 | rsync -aHAXSv0 --files-from=- . user@host.dom:/dest
GNU cp(1) und openSSH scp(1):
# cd ./source; cp -a . /dest # cd ./source; scp -pr . user@host.dom:/dest
GNU tar(1):
# (cd ./source && tar cf - . ) | (cd /dest && tar xvfp - ) # (cd ./source && tar cf - . ) | ssh user@host.dom '(cd /dest && tar xvfp - )'
cpio(1):
# cd ./source; find . -print0 | cpio -pvdm --null --sparse /dest
Sie können in allen Beispielen, die einen ".
" enthalten,
diesen ".
" durch "foo
" ersetzen, um
Dateien aus dem Verzeichnis "./source/foo
" in das
Verzeichnis "/dest/foo
" zu kopieren.
Auch kann in allen Beispielen, die einen ".
" enthalten,
dieser ".
" durch einen absoluten Pfad wie
"/pfad/zu/source/foo
" ersetzt werden, damit kann dann auf
"cd ./source;
" verzichtet werden. Dadurch werden,
abhängig von den verwendeten Werkzeugen, die Dateien an unterschiedliche
Orte kopiert:
bei
rsync(8),
GNU
cp(1)
und
scp(1):
nach "/dest/foo
";
bei GNU
tar(1)
und
cpio(1):
nach "/dest/pfad/zu/source/foo
".
![]() |
Tipp |
---|---|
rsync(8)
und GNU
cp(1)
unterstützen die Option " |
find(1) wird verwendet, um Dateien für Archivierungs- und Kopierbefehle auszuwählen (lesen Sie Abschnitt 10.1.3, „Aufrufe für Archivierungsoperationen“ und Abschnitt 10.1.4, „Aufrufe für Kopieroperationen“) oder xargs(1) (Näheres in Abschnitt 9.3.9, „Einen Befehl wiederholt mit einer Schleife über verschiedene Dateien ausführen“). Dies kann mit deren Befehlsargumenten noch erweitert werden.
Die grundsätzliche Syntax von find(1) kann wie folgt zusammengefasst werden:
Seine bedingten Argumente werden von links nach rechts ausgewertet.
Die Auswertung wird beendet, sobald ihr Resultat ermittelt wurde.
Ein "logisches ODER" (definiert über
"-o
" zwischen den Bedingungen) hat eine niedrigere
Priorität als ein "logisches UND" (das
über "-a
" oder nichts zwischen den Bedingungen definiert
wird).
Ein "logisches NICHT" (definiert über
"!
" vor der Bedingung) hat eine höhere Priorität als ein
"logisches UND".
"-prune
" liefert immer ein logisches WAHR zurück und, falls es ein Verzeichnis ist, wird
die Suche nach Dateien an diesem Punkt beendet.
"-name
" findet Dateien über den Anfang des Dateinamens
mittels Shell-Glob-Suchmuster (lesen Sie dazu Abschnitt 1.5.6, „Shell-Glob“), findet sie aber über Metazeichen wie
"*
" und "?
" auch bei einem führenden
".
" (neue POSIX-Funktionalität).
"-regex
" findet Dateien mit vollständigem Pfad
standardmäßig über Emacs-artige reguläre Ausdrücke (BRE, nähere Infos finden Sie in Abschnitt 1.6.2, „Reguläre Ausdrücke“).
"-size
" findet Dateien basierend auf der Dateigröße (mit
einem "+
" vor dem Wert für größer, mit einem
"-
" für kleiner).
"-newer
" findet Dateien, die neuer sind als in dem
Argument angegeben.
"-print0
" liefert immer ein logisches WAHR zurück und gibt den kompletten Dateinamen
(abgeschlossen durch ein Nullzeichen)
auf der Standardausgabe aus.
find(1) wird oft in einem idiomatischen Stil verwendet, wie hier:
# find /pfad/zu \ -xdev -regextype posix-extended \ -type f -regex ".*\.cpio|.*~" -prune -o \ -type d -regex ".*/\.git" -prune -o \ -type f -size +99M -prune -o \ -type f -newer /pfad/zu/zeitstempel -print0
Das bedeutet folgendes:
nach allen Dateien suchen, beginnend in "/pfad/zu
";
die Suche global auf das Dateisystem beschränken, in dem sie begonnen wurde, und stattdessen reguläre Ausdrücke (ERE, lesen Sie dazu Abschnitt 1.6.2, „Reguläre Ausdrücke“) verwenden;
Dateien ausschließen, auf die die regulären Ausdrücke
".*\.cpio
" oder ".*~
" zutreffen, indem
die Suche abgebrochen wird;
Verzeichnisse ausschließen, auf die der reguläre Ausdruck
".*/\.git
" zutrifft, indem die Suche abgebrochen wird;
Dateien ausschließen, die größer als 99 Megabyte (1048576 Byte) sind, indem die Suche abgebrochen wird;
Dateinamen ausgeben, die obige Suchkriterien erfüllen und neuer als
"/path/to/timestamp
" sind.
Bitte beachten Sie die idiomatische Verwendung von "-prune
-o
", um in obigen Beispielen Dateien auszuschließen.
![]() |
Anmerkung |
---|---|
Auf Unix-artigen Nicht-Debian-Systemen
werden einige Optionen von
find(1)
unter Umständen nicht unterstützt. Versuchen Sie in diesem Fall, die
Suchmethoden anzupassen und " |
Wenn Sie Speichermedien für die Sicherung wichtiger Daten suchen, sollten Sie sorgfältig deren Einschränkungen abwägen. Für eine kleine persönliche Datensicherung verwende ich CD-R und DVD-R von einem Markenhersteller und lagere die Disks in einer kühlen, dunklen, trockenen und sauberen Umgebung. (Für die professionelle Nutzung scheinen Tapes (Speicherbänder) zur Archivierung sehr beliebt zu sein.)
![]() |
Anmerkung |
---|---|
Ein feuerbeständiger Tresor ist gedacht für Dokumente in Papierform. Jedoch haben die meisten Speichermedien eine niedrigere Temperaturtoleranz als Papier. Ich baue auf mehrere sicher verschlüsselte Kopien, die an verschiedenen sicheren Orten aufbewahrt werden. |
Optimistische Angabe der Lebensdauer von Speichermedien, gefunden im Internet (überwiegend Herstellerangaben):
100 Jahre und mehr: säurefreies Papier mit Tinte;
100 Jahre: Optische Speichermedien (CD/DVD, CD-R/DVD-R);
30 Jahre: Magnetische Speichermedien (Bänder, Disketten);
20 Jahre: Optische Medien basierend auf Phasenänderung (CD-RW).
Hierbei sind keine mechanischen Ausfälle durch Handhabung usw. berücksichtigt.
Optimistische Angabe von Schreibzyklen der Speichermedien, gefunden im Internet (überwiegend Herstellerangaben):
250000 Zyklen und mehr: Festplattenlaufwerk;
10000 Zyklen und mehr: Flash-Speicher;
1000 Zyklen: CD-RW/DVD-RW;
1 Zyklus: CD-R/DVD-R, Papier.
![]() |
Achtung |
---|---|
Die obigen Angaben zu Lebensdauer und Schreibzyklen sollten nicht für Entscheidungen bezüglich kritischer Datenspeicherung herangezogen werden. Bitte konsultieren Sie in diesem Fall die spezifischen Produktinformationen des Herstellers. |
![]() |
Tipp |
---|---|
Da CD-R/DVD-R und Papier nur einmal beschrieben werden können, schützen sie von Natur aus vor dem versehentlichen Datenverlust durch Überschreiben. Dies ist ein Vorteil! |
![]() |
Tipp |
---|---|
Wenn Sie eine schnelle und wiederholte Sicherung großer Datenmengen benötigen, könnte eine Festplatte in einem fernen Rechner, verbunden über eine schnelle Internetverbindung, die einzige realistische Option sein. |
Wechseldatenträger können folgende Geräte sein:
USB-Flash-Speicher (USB-Stick);
Optisches Laufwerk (CD/DVD/BD);
Digitalkamera;
Digitaler Mediaplayer.
Sie können über eine dieser Möglichkeiten verbunden sein:
Moderne Arbeitsplatzumgebungen wie GNOME und KDE können diese
Wechseldatenträger auch ohne einen entsprechenden
"/etc/fstab
"-Eintrag automatisiert einbinden.
![]() |
Tipp |
---|---|
Automatisch eingebundene Geräte haben eventuell die mount-Option
" |
![]() |
Tipp |
---|---|
In modernen Arbeitsplatzumgebungen funktioniert das automatische Einbinden
von Laufwerken nur, wenn diese Geräte nicht in
" |
Der Einbindungspunkt wird in modernen Umgebungen als
"/media/<laufwerksbezeichnung>
" abgebildet; die
Laufwerksbezeichnung (manchmal auch als Disk-Label bezeichnet) kann wie
folgt angepasst werden:
mlabel(1) bei FAT-Dateisystemen;
genisoimage(1)
mit der Option "-V
" bei ISO9660-Dateisystemen;
tune2fs(1)
mit der Option "-L
" bei ext2-/ext3-/ext4-Dateisystemen.
![]() |
Tipp |
---|---|
Die verwendete Zeichenkodierung muss unter Umständen als mount-Option angegeben werden (lesen Sie dazu Abschnitt 8.4.6, „Dateinamenkodierung“). |
![]() |
Tipp |
---|---|
Die Verwendung des grafischen GUI-Menüs zur Trennung eines eingebundenen
Dateisystems könnte auch dessen dynamisch erzeugte Gerätedatei
(z.B. " |
Um Daten mit anderen Systemen über Wechseldatenträger auszutauschen, sollten Sie diese mit einem Dateisystem formatieren, das von beiden Systemen unterstützt wird.
Tabelle 10.3. Liste von Dateisystemen für Wechseldatenträger mit typischen Anwendungsszenarien
Dateisystem | Beschreibung des typischen Anwendungsszenarios |
---|---|
FAT12 | Plattformübergreifender Datenaustausch mittels Diskette (<32 MiB) |
FAT16 | Plattformübergreifender Datenaustausch mittels kleiner festplatten-ähnlicher Geräte (<2 GiB) |
FAT32 | Plattformübergreifender Datenaustausch mittels großer festplatten-ähnlicher Geräte (<8 TiB, unterstützt von Systemen neuer als MS Windows95 OSR2) |
NTFS | Plattformübergreifender Datenaustausch mittels großer festplatten-ähnlicher Geräte (nativ unterstützt von MS Windows NT und späteren Versionen, außerdem unterstützt durch NTFS-3G via FUSE unter Linux) |
ISO9660 | Plattformübergreifender Austausch statischer Daten mittels CD-R und DVD+/-R |
UDF | inkrementelles Schreiben von Daten auf CD-R und DVD+/-R (neu) |
MINIX-Dateisystem | speicherplatz-effizientes Ablegen von Unix-Daten auf Diskette |
ext2-Dateisystem | Datenaustausch mit älteren Linux-Systemen auf festplatten-ähnlichen Geräten |
ext3-Dateisystem | Datenaustausch mit älteren Linux-Systemen auf festplatten-ähnlichen Geräten |
ext4-Dateisystem | Datenaustausch mit aktuellen Linux-Systemen auf festplatten-ähnlichen Geräten |
![]() |
Tipp |
---|---|
Details zum plattformübergreifenden Datenaustausch mit Verschlüsselung auf Geräteebene finden Sie in Abschnitt 9.8.1, „Verschlüsselung von Wechseldatenträgern mit dm-crypt/LUKS“. |
Das FAT-Dateisystem wird von nahezu allen modernen Dateisystemen unterstützt und ist für den Datenaustausch über Wechseldatenträger sehr nützlich.
Wenn Sie Geräte wie externe Festplatten für den plattformübergreifenden Datenaustausch mit dem FAT-Dateisystem formatieren, sollten die folgenden Varianten eine sichere Wahl sein:
Partitionieren Sie das Medium mit fdisk(8), cfdisk(8) oder parted(8) (lesen Sie dazu Abschnitt 9.5.2, „Konfiguration der Plattenpartitionen“) mit einer einzigen primären Partition und markieren Sie sie wie folgt:
Typ "6" (FAT16) für Medien kleiner als 2 GB;
Typ "c" (FAT32, LBA) für größere Medien.
Formatieren der primären Partition mit mkfs.vfat(8) wie folgt:
einfach über den Gerätenamen, z.B. "/dev/sda1
" für FAT16;
über die explizite Option und den Gerätenamen, z.B. "-F 32
/dev/sda1
" für FAT32.
Wenn das FAT- oder ISO9660-Dateisystem für den Dateiaustausch verwendet wird, sollte folgendes eine sichere Variante sein:
archivieren der Dateien in eine Archivdatei mittels tar(1) oder cpio(1), um die langen Dateinamen, symbolischen Links, originalen Unix-Dateiberechtigungen und Benutzerinformationen zu erhalten;
splitten der Archivdatei in Stücke kleiner als 2 GiB mittels split(1), um so die Beschränkung der Dateigröße zu umgehen;
verschlüsseln der Archivdatei, um den Inhalt vor unberechtigtem Zugriff zu schützen.
![]() |
Anmerkung |
---|---|
Bei dem FAT-Dateisystem liegt, begründet durch sein Design, die maximale
Dateigröße bei |
![]() |
Anmerkung |
---|---|
Microsoft selbst empfiehlt FAT nicht für Laufwerke oder Partitionen über 200 MB Größe. Microsoft hebt die Nachteile wie ineffiziente Speicherplatznutzung in seiner "Übersicht über die Dateisysteme FAT, HPFS und NTFS" hervor. Natürlich sollten wir für Linux normalerweise das ext4-Dateisystem nutzen. |
![]() |
Tipp |
---|---|
Mehr Informationen über Dateisysteme und Dateisystemzugriffe finden Sie im "Filesystems HOWTO". |
Wenn Sie Daten mit anderen Systemen über das Netzwerk austauschen, sollten Sie allgemein gängige Dienste verwenden. Hier einige Hinweise:
Tabelle 10.4. Liste von Netzwerkdiensten mit typischen Anwendungsszenarien
Netzwerkdienst | Beschreibung des typischen Anwendungsszenarios |
---|---|
SMB/CIFS - über Netzwerk mit Samba eingebundenes Dateisystem |
Datenaustausch über "Microsoft Windows Network", Näheres in
smb.conf(5)
und The Official Samba 3.x.x
HOWTO and Reference Guide oder im samba-doc -Paket
|
NFS - über Netzwerk mittels Linux-Kernel eingebundenes Dateisystem | Datenaustausch über "Unix/Linux Network", Näheres in exports(5) und im Linux NFS-HOWTO |
HTTP-Dienst | Datenaustausch zwischen Web-Server/-Client |
HTTPS-Dienst | Datenaustausch zwischen Web-Server/-Client mit verschlüsseltem Secure Sockets Layer (SSL) oder Transport Layer Security (TLS) |
FTP-Dienst | Datenaustausch zwischen FTP-Server/-Client |
Obwohl Dateisysteme, die über solche Netzwerk-gestützten Transfermethoden eingebunden sind, für den Datenaustausch sehr praktisch sind, könnten Sie unsicher sein. Die genutzte Netzwerkverbindung muss wie folgt abgesichert sein:
Lesen Sie auch Abschnitt 6.10, „Weitere Netzwerkanwendungs-Server“ und Abschnitt 6.11, „Weitere Netzwerkanwendungs-Clients“.
Wir alle wissen, dass Computer manchmal defekt sein können oder menschliche Fehler System- und Datenausfälle verursachen. Aktionen zur Datensicherung und -wiederherstellung sind unverzichtbarer Teil einer erfolgreichen Systemadministration. Alle möglichen Fehlervarianten werden Sie eines Tages ereilen.
![]() |
Tipp |
---|---|
Halten Sie Ihr Datensicherungssystem einfach und führen Sie häufig Sicherungen durch. Aktuelle Sicherungen von seinen Daten zu haben ist wichtiger als die technische Qualität der Sicherungsmethodik. |
Es gibt drei Schlüsselfaktoren, die letztendig die Sicherungs- und Wiederherstellungsstrategie bestimmen:
Zu wissen, was man sichern und wiederherstellen muss:
Daten, die direkt von Ihnen selbst erstellt wurden: Daten in
"~/
";
Daten, die von Anwendungen, die Sie verwenden, erstellt wurden: Daten in
"/var/
" (außer "/var/cache/
",
"/var/run/
" und "/var/tmp/
");
Systemkonfigurationsdateien: Daten in "/etc/
";
Lokale Software: Daten in "/usr/local/
" oder
"/opt/
";
Informationen zur Systeminstallation: Aufzeichnungen über wichtige Schritte (Partitionierung, …) in einfacher Textform;
Daten, von denen Sie wissen, dass sie wichtig sind, bestätigt durch im Vornherein versuchsweise durchgeführte Wiederherstellungsoperationen.
Wissen, wie Sie Daten sichern und wiederherstellen:
Sicheres Speichern von Daten: geschützt vor Überschreiben und Systemausfällen;
Häufige Datensicherungen: Sicherungen planen;
Redundante Datensicherungen: Spiegeln der Sicherungsdateien;
Idiotensicheres Vorgehen: Sicherung durch einen einfachen Befehl.
Bewertung der entstehenden Risiken und Kosten:
Wert der Daten, falls sie verloren gehen;
Für die Sicherung benötigte Ressourcen: Personen, Hardware, Software, …;
Mögliche Ausfälle und deren Wahrscheinlichkeit.
![]() |
Anmerkung |
---|---|
Machen Sie keine Sicherungen von den Pseudo-Dateisystemen in
|
Aus Gründen der sicheren Speicherung sollten die Daten zumindest auf verschiedenen Festplattenpartitionen, bevorzugt sogar auf separaten Festplatten und Rechnern abgelegt werden, um Beschädigungen von Dateisystemen standzuhalten. Wichtige Daten werden am besten auf Medien gespeichert, die nur einmal beschrieben werden können (wie CD-R/DVD-R), um versehentliches Überschreiben auszuschließen. (In Abschnitt 9.7, „Binärdaten“ lesen Sie, wie Sie von der Befehlszeile aus auf die Speichermedien schreiben können. Die grafische Oberfläche der GNOME-Arbeitsplatzumgebung bietet Ihnen auch einen einfachen Weg über das Menü: "Orte→CD/DVD-Ersteller".)
![]() |
Anmerkung |
---|---|
Sie sollten eventuell einige Anwendungs-Daemons wie den MTA (lesen Sie dazu Abschnitt 6.3, „Mail Transfer Agent (MTA)“) beenden, während Sie die Datensicherung durchführen. |
![]() |
Anmerkung |
---|---|
Besondere Sorgfalt bei Sicherung und Wiederherstellung sollte
Identitäts-bezogenen Dateien gelten, wie
" |
![]() |
Anmerkung |
---|---|
Wenn Sie einen Cron-Job als Benutzerprozess ausführen, müssen Sie die
Dateien im Verzeichnis " |
Hier eine Auswahl erwähnenswerter, im Debian-System verfügbarer Datensicherungsprogramme:
Tabelle 10.5. Liste von Datensicherungsprogrammen
Paket | Popcon | Größe | Beschreibung |
---|---|---|---|
dump
|
V:1, I:6 | 341 | 4.4bsd dump(8)- und restore(8)-Programm für ext2/ext3/ext4-Dateisysteme |
xfsdump
|
V:0, I:11 | 838 | dump (Abbilderstellung) und restore (Wiederherstellung) mit xfsdump(8) und xfsrestore(8) für das XFS-Dateisystem unter GNU/Linux und IRIX |
backupninja
|
V:4, I:4 | 329 | ressourcenschonendes, erweiterbares Meta-Backup-System |
bacula-common
|
V:10, I:18 | 2059 | Bacula: Datensicherung, -wiederherstellung und -verifizierung über das Netzwerk - gemeinsame Hilfsdateien |
bacula-client
|
I:5 | 167 | Bacula: Datensicherung, -wiederherstellung und -verifizierung über das Netzwerk - Client-Metapaket |
bacula-console
|
V:1, I:6 | 68 | Bacula: Datensicherung, -wiederherstellung und -verifizierung über das Netzwerk - Textkonsole |
bacula-server
|
I:1 | 167 | Bacula: Datensicherung, -wiederherstellung und -verifizierung über das Netzwerk - Server-Metapaket |
amanda-common
|
V:1, I:2 | 9964 | Amanda: Advanced Maryland Automatic Network Disk Archiver (Netzwerk-Backup-System - Bibliotheken) |
amanda-client
|
V:1, I:2 | 1072 | Amanda: Advanced Maryland Automatic Network Disk Archiver (Netzwerk-Backup-System - Client) |
amanda-server
|
V:0, I:0 | 1044 | Amanda: Advanced Maryland Automatic Network Disk Archiver (Netzwerk-Backup-System - Server) |
backup-manager
|
V:1, I:2 | 571 | befehlszeilen-basiertes Datensicherungs-Werkzeug |
backup2l
|
V:1, I:1 | 113 | wartungsarmes Sicherungs-/Wiederherstellungsprogramm für mount-fähige Medien (festplatten-basiert) |
backuppc
|
V:4, I:4 | 2232 | BackupPC ist ein hochleistungsfähiges System der Enterprise-Klasse zur Datensicherung von PCs (festplatten-basiert) |
duplicity
|
V:8, I:15 | 1535 | Inkrementelles Backup (auch von fern) |
flexbackup
|
V:0, I:0 | 242 | Inkrementelles Backup (auch von fern) |
rdiff-backup
|
V:9, I:17 | 704 | Inkrementelles Backup (auch von fern) |
restic
|
V:0, I:0 | 15987 | Inkrementelles Backup (auch von fern) |
rsnapshot
|
V:6, I:12 | 452 | Inkrementelles Backup (auch von fern) |
slbackup
|
V:0, I:0 | 146 | Inkrementelles Backup (auch von fern) |
Datensicherungs-Werkzeuge haben alle ihren speziellen Fokus:
Mondo Rescue ist ein Backup-System, das die schnelle Wiederherstellung eines vollständigen Systems von CD/DVD ermöglicht, ohne dass dabei die normalen Systeminstallations-Prozesse durchlaufen werden müssen.
Regelmäßige Sicherungen von Nutzerdaten können über ein einfaches Skript (siehe Abschnitt 10.2.2, „Ein Beispielskript für die Systemsicherung“) und cron(8) realisiert werden.
Bacula, Amanda und BackupPC sind voll ausgestattete Backup-Lösungen, die auf die regelmäßige Datensicherung über Netzwerk fokussiert sind.
Grundlegende Werkzeuge (in Abschnitt 10.1.1, „Archivierungs- und Kompressionswerkzeuge“ und Abschnitt 10.1.2, „Kopier- und Synchronisationswerkzeuge“ beschrieben) können verwendet werden, um Systemdatensicherungen über eigene Skripte durchzuführen. Solche Skripte können wie folgt erweitert werden:
Das restic
-Paket ermöglicht inkrementelle
Datensicherungen (auch auf ferne Rechner).
Auch das rdiff-backup
-Paket ermöglicht inkrementelle
Datensicherungen (ebenfalls auf ferne Rechner).
Das dump
-Paket hilft bei der inkrementellen und
effizienten Archivierung und Wiederherstellung eines kompletten
Dateisystems.
![]() |
Tipp |
---|---|
Lesen Sie " |
Bei einem privatem Debian-Arbeitsplatzsystem mit der
Unstable
-Suite muss ich lediglich persönliche und
kritische Daten sichern. Ich installiere das System eh einmal im Jahr
neu. Daher sehe ich keinen Grund, das komplette System zu sichern oder ein
voll ausgestattetes Backup-Werkzeug zu installieren.
Ich verwende ein einfaches Skript, um ein Backup-Archiv zu erstellen und es über eine grafische GUI-Oberfläche auf CD/DVD zu brennen. Hier ein Beispiel für dieses Skript:
#!/bin/sh -e # Copyright (C) 2007-2008 Osamu Aoki <osamu@debian.org>, Public Domain BUUID=1000; USER=osamu # UID and name of a user who accesses backup files BUDIR="/var/backups" XDIR0=".+/Mail|.+/Desktop" XDIR1=".+/\.thumbnails|.+/\.?Trash|.+/\.?[cC]ache|.+/\.gvfs|.+/sessions" XDIR2=".+/CVS|.+/\.git|.+/\.svn|.+/Downloads|.+/Archive|.+/Checkout|.+/tmp" XSFX=".+\.iso|.+\.tgz|.+\.tar\.gz|.+\.tar\.bz2|.+\.cpio|.+\.tmp|.+\.swp|.+~" SIZE="+99M" DATE=$(date --utc +"%Y%m%d-%H%M") [ -d "$BUDIR" ] || mkdir -p "BUDIR" umask 077 dpkg --get-selections \* > /var/lib/dpkg/dpkg-selections.list debconf-get-selections > /var/cache/debconf/debconf-selections { find /etc /usr/local /opt /var/lib/dpkg/dpkg-selections.list \ /var/cache/debconf/debconf-selections -xdev -print0 find /home/$USER /root -xdev -regextype posix-extended \ -type d -regex "$XDIR0|$XDIR1" -prune -o -type f -regex "$XSFX" -prune -o \ -type f -size "$SIZE" -prune -o -print0 find /home/$USER/Mail/Inbox /home/$USER/Mail/Outbox -print0 find /home/$USER/Desktop -xdev -regextype posix-extended \ -type d -regex "$XDIR2" -prune -o -type f -regex "$XSFX" -prune -o \ -type f -size "$SIZE" -prune -o -print0 } | cpio -ov --null -O $BUDIR/BU$DATE.cpio chown $BUUID $BUDIR/BU$DATE.cpio touch $BUDIR/backup.stamp
Dieses Beispielskript ist dazu gedacht, als root ausgeführt zu werden.
Ich gehe davon aus, dass Sie es anpassen und wie folgt ausführen:
Bearbeiten Sie das Skript, so dass all Ihre wichtigen Daten enthalten sind (lesen Sie dazu Abschnitt 10.1.5, „Aufrufe für die Auswahl von Dateien“ und Abschnitt 10.2, „Datensicherung und -wiederherstellung“).
Ersetzen Sie "find … -print0
" durch "find …
-newer $BUDIR/backup.stamp -print0
", um eine inkrementelle
Sicherung zu erstellen.
Transferieren Sie die Sicherungsdateien mittels scp(1) oder rsync(1) auf einen fernen Rechner oder brennen Sie sie für zusätzliche Sicherheit auf CD/DVD. (Ich verwende ein grafisches GNOME-Programm zum Brennen auf CD/DVD. Lesen Sie Abschnitt 12.1.8, „Shellskript-Beispiel mit zenity“ für zusätzliche Redundanz.
Halten Sie es einfach!
![]() |
Tipp |
---|---|
Sie können die debconf-Konfigurationsdaten mit
" |
Für eine Datensammlung in einem Verzeichnisbaum ermöglicht das Kopieren mit
"cp -a
" eine normale Datensicherung.
Bei vielen großen, nicht zu überschreibenden statischen Daten in einem
Verzeichnisbaum wie der unterhalb des Verzeichnisses
"/var/cache/apt/packages/
" bieten harte Links mit
"cp -al
" eine Alternative zum normalen Backup bei
effizienter Nutzung des Festplattenplatzes.
Hier ein Kopierskript für die Datensicherung, das ich
bkup
genannt habe. Dieses Skript kopiert alle Dateien im
aktuellen Verzeichnis, die nicht unter Versionskontrolle stehen (nicht-VCS),
in das Elternverzeichnis oder auf einen fernen Rechner.
#!/bin/sh -e # Copyright (C) 2007-2008 Osamu Aoki <osamu@debian.org>, Public Domain fdot(){ find . -type d \( -iname ".?*" -o -iname "CVS" \) -prune -o -print0;} fall(){ find . -print0;} mkdircd(){ mkdir -p "$1";chmod 700 "$1";cd "$1">/dev/null;} FIND="fdot";OPT="-a";MODE="CPIOP";HOST="localhost";EXTP="$(hostname -f)" BKUP="$(basename $(pwd)).bkup";TIME="$(date +%Y%m%d-%H%M%S)";BU="$BKUP/$TIME" while getopts gcCsStrlLaAxe:h:T f; do case $f in g) MODE="GNUCP";; # cp (GNU) c) MODE="CPIOP";; # cpio -p C) MODE="CPIOI";; # cpio -i s) MODE="CPIOSSH";; # cpio/ssh t) MODE="TARSSH";; # tar/ssh r) MODE="RSYNCSSH";; # rsync/ssh l) OPT="-alv";; # hardlink (GNU cp) L) OPT="-av";; # copy (GNU cp) a) FIND="fall";; # find all A) FIND="fdot";; # find non CVS/ .???/ x) set -x;; # trace e) EXTP="${OPTARG}";; # hostname -f h) HOST="${OPTARG}";; # user@remotehost.example.com T) MODE="TEST";; # test find mode \?) echo "use -x for trace." esac; done shift $(expr $OPTIND - 1) if [ $# -gt 0 ]; then for x in $@; do cp $OPT $x $x.$TIME; done elif [ $MODE = GNUCP ]; then mkdir -p "../$BU";chmod 700 "../$BU";cp $OPT . "../$BU/" elif [ $MODE = CPIOP ]; then mkdir -p "../$BU";chmod 700 "../$BU" $FIND|cpio --null --sparse -pvd ../$BU elif [ $MODE = CPIOI ]; then $FIND|cpio -ov --null | ( mkdircd "../$BU"&&cpio -i ) elif [ $MODE = CPIOSSH ]; then $FIND|cpio -ov --null|ssh -C $HOST "( mkdircd \"$EXTP/$BU\"&&cpio -i )" elif [ $MODE = TARSSH ]; then (tar cvf - . )|ssh -C $HOST "( mkdircd \"$EXTP/$BU\"&& tar xvfp - )" elif [ $MODE = RSYNCSSH ]; then rsync -aHAXSv ./ "${HOST}:${EXTP}-${BKUP}-${TIME}" else echo "Any other idea to backup?" $FIND |xargs -0 -n 1 echo fi
Dies sollen Befehlsbeispiele sein. Bitte lesen Sie das Skript und passen Sie es für sich selbst an, bevor Sie es nutzen.
![]() |
Tipp |
---|---|
Ich habe dieses |
![]() |
Tipp |
---|---|
Um Abbilder inklusive der Historie von einem Quelldateibaum oder einem Konfigurationsdateibaum zu erstellen, ist es einfacher und bezüglich des Speicherplatzes effizienter, git(7) zu verwenden (lesen Sie dazu Abschnitt 10.6.5, „Git zur Aufzeichnung der Historie von Konfigurationsdateien“). |
Die Sicherheitsinfrastruktur für Ihre Daten wird durch eine Kombination verschiedener Programme gewährleistet: Verschlüsselungswerkzeug, Message-Digest-Werkzeug und Signaturwerkzeug.
Tabelle 10.6. Liste von Werkzeugen für die Datensicherheits-Infrastruktur
Paket | Popcon | Größe | Befehl | Beschreibung |
---|---|---|---|---|
gnupg
|
V:698, I:998 | 696 | gpg(1) | GNU Privacy Guard - OpenPGP Verschlüsselungs- und Signaturwerkzeug |
gpgv
|
V:873, I:999 | 809 | gpgv(1) | GNU Privacy Guard - Werkzeug zur Verifizierung von Signaturen |
paperkey
|
V:0, I:4 | 55 | paperkey(1) | lediglich die geheimen Informationen aus geheimen OpenPGP-Schlüsseln extrahieren |
cryptsetup
|
V:34, I:79 | 376 | cryptsetup(8), … | Hilfsprogramme für die dm-crypto-Blockgeräte-Verschlüsselung (enthält Unterstützung für LUKS) |
ecryptfs-utils
|
V:6, I:9 | 396 | ecryptfs(7), … | Hilfsprogramme für die auf "stacked filesystems" (überlagerten Dateisystemen) aufbauende ecryptfs-Verschlüsselung |
coreutils
|
V:878, I:999 | 15016 | md5sum(1) | MD5-Message-Digest (Prüfsummen) berechnen und überprüfen |
coreutils
|
V:878, I:999 | 15016 | sha1sum(1) | SHA1-Message-Digest (Prüfsummen) berechnen und überprüfen |
openssl
|
V:794, I:991 | 1303 | openssl(1ssl) |
Message-Digest mit "openssl dgst " berechnen (OpenSSL)
|
In Abschnitt 9.8, „Tipps zur Datenverschlüsselung“ finden Sie Infos über dm-crypto und ecryptfs, die automatische Datenverschlüsselungs-Infrastrukturen über Linux-Kernelmodule implementieren.
Hier einige Befehle für die grundlegende Schlüsselverwaltung mit GNU Privacy Guard:
Tabelle 10.7. Liste von GNU Privacy Guard-Befehlen für die Schlüsselverwaltung
Befehl | Beschreibung |
---|---|
gpg --gen-key
|
einen neuen Schlüssel generieren |
gpg --gen-revoke meine_Nutzer_ID
|
einen Widerrufschlüssel (revoke key) für meine_Nutzer_ID generieren |
gpg --edit-key Nutzer_ID
|
Schlüssel interaktiv editieren, "help" eingeben für weitere Hilfe |
gpg -o datei --export
|
alle Schlüssel in datei exportieren |
gpg --import datei
|
alle Schlüssel aus datei importieren |
gpg --send-keys Nutzer_ID
|
Schlüssel von Nutzer_ID zum Schlüsselserver übertragen |
gpg --recv-keys Nutzer_ID
|
Schlüssel von Nutzer_ID vom Schlüsselserver empfangen |
gpg --list-keys Nutzer_ID
|
Schlüssel von Nutzer_ID auflisten |
gpg --list-sigs user_ID
|
Signaturen von Nutzer_ID auflisten |
gpg --check-sigs Nutzer_ID
|
Signaturen von Nutzer_ID überprüfen |
gpg --fingerprint Nutzer_ID
|
Fingerabdruck von Nutzer_ID überprüfen |
gpg --refresh-keys
|
lokalen Schlüsselring aktualisieren |
Hier die Bedeutung des Vertrauenscodes:
Tabelle 10.8. Liste der Bedeutungen des Vertrauenscodes
Code | Beschreibung des Vertrauenscodes |
---|---|
-
|
Kein Besitzervertrauen zugewiesen / noch nicht berechnet |
e
|
Vertrauensberechnung fehlgeschlagen |
q
|
nicht genügend Informationen für Berechnung |
n
|
diesem Schlüssel niemals vertrauen |
m
|
gerade noch vertrauenswert |
f
|
voll vertrauenswert |
u
|
absolut vertrauenswert |
Folgendes lädt meinen Schlüssel "1DD8D791
" auf den
populären Schlüsselserver "hkp://keys.gnupg.net
" hoch:
$ gpg --keyserver hkp://keys.gnupg.net --send-keys 1DD8D791
Ein gutes Standard-Schlüsselserver-Setup in
"~/.gnupg/gpg.conf
" (oder dem alten Ort
"~/.gnupg/options
") enthält folgendes:
keyserver hkp://keys.gnupg.net
Mit dem folgenden Befehl beziehen Sie unbekannte Schlüssel vom Schlüsselserver:
$ gpg --list-sigs --with-colons | grep '^sig.*\[User ID not found\]' |\ cut -d ':' -f 5| sort | uniq | xargs gpg --recv-keys
Es gab einen Fehler in OpenPGP Public
Key Server (Versionen vor 0.9.6), durch den Schlüssel mit mehr als
zwei Unterschlüsseln korrumpiert wurden. Das neue
gnupg
-Paket (>1.2.1-2) kann mit diesen korrumpierten
Unterschlüsseln umgehen. Lesen Sie in
gpg(1)
den Abschnitt zur Option "--repair-pks-subkey-bug
".
Hier einige Beispiele für die Verwendung von GNU Privacy Guard mit Dateien:
Tabelle 10.9. Liste von GNU Privacy Guard-Befehlen mit Dateien
Befehl | Beschreibung |
---|---|
gpg -a -s datei
|
Signieren von datei in die ASCII-bewehrte datei.asc |
gpg --armor --sign datei
|
" |
gpg --clearsign datei
|
Signieren einer Nachricht mit Klartextsignatur |
gpg --clearsign datei|mail foo@example.org
|
Versenden einer Nachricht mit Klartextsignatur an
foo@example.org
|
gpg --clearsign --not-dash-escaped patch-datei
|
Klartext-signieren von patch-datei |
gpg --verify datei
|
eine klartextsignierte datei verifizieren |
gpg -o datei.sig -b datei
|
Erzeugen einer losgelösten Signatur |
gpg -o datei.sig --detach-sig datei
|
" |
gpg --verify datei.sig datei
|
Verifizieren von datei mit datei.sig |
gpg -o crypt_datei.gpg -r name -e datei
|
Verschlüsselung mit öffentlichem Schlüssel für name von datei in Binärdatei crypt_datei.pgp |
gpg -o crypt_datei.gpg --recipient name --encrypt datei
|
" |
gpg -o crypt_datei.asc -a -r name -e datei
|
Verschlüsselung mit öffentlichem Schlüssel für name von datei in ASCII-bewehrte Datei crypt_datei.pgp |
gpg -o crypt_datei.gpg -c datei
|
symmetrische Verschlüsselung von "datei" in crypt_datei.gpg |
gpg -o crypt_datei.gpg --symmetric datei
|
" |
gpg -o crypt_datei.asc -a -c datei
|
symmetrische Verschlüsselung für name von datei in ASCII-bewehrte Datei crypt_datei.asc |
gpg -o datei -d crypt_datei.gpg -r name
|
Entschlüsselung |
gpg -o datei --decrypt crypt_datei.gpg
|
" |
Fügen Sie Folgendes zu "~/.muttrc
" hinzu, um zu
verhindern, dass das langsame GnuPG automatisch gestartet wird, während es
durch Drücken von "S
" im Indexmenü händisch gestartet
werden kann:
macro index S ":toggle pgp_verify_sig\n" set pgp_verify_sig=no
Das gnupg
-Plugin ermöglicht Ihnen, GnuPG für Dateien mit
den Endungen ".gpg
", ".asc
" und
".ppg
" transparent laufen zu lassen:
# aptitude install vim-scripts vim-addon-manager $ vim-addons install gnupg
md5sum(1) enthält ein Werkzeug, um über die in RFC1321 beschriebene Methode eine Digest-Datei zu erzeugen und jede Datei darüber zu verifizieren:
$ md5sum foo bar >baz.md5 $ cat baz.md5 d3b07384d113edec49eaa6238ad5ff00 foo c157a79031e1c40f85931829bc5fc552 bar $ md5sum -c baz.md5 foo: OK bar: OK
![]() |
Anmerkung |
---|---|
Die Berechnung der MD5-Prüfsumme ist weniger CPU-intensiv als die für die krypthographische Signatur durch GNU Privacy Guard (GnuPG). Üblicherweise ist nur die Digest-Datei der obersten Ebene (z.B. das Wurzelverzeichnis eines Verzeichnisbaums) kryptographisch signiert, um die Datenintegrität sicherzustellen. |
Es gibt viele Werkzeuge für die Zusammenführung von Quellcode. Folgende Befehle haben meine Aufmerksamkeit erregt:
Tabelle 10.10. Liste von Werkzeugen zur Quellcode-Zusammenführung
Paket | Popcon | Größe | Befehl | Beschreibung |
---|---|---|---|---|
diffutils
|
V:860, I:983 | 1394 | diff(1) | Dateien Zeile für Zeile vergleichen |
diffutils
|
V:860, I:983 | 1394 | diff3(1) | drei Dateien Zeile für Zeile vergleichen und zusammenführen |
vim
|
V:121, I:390 | 2660 | vimdiff(1) | zwei Dateien nebeneinander in vim vergleichen |
patch
|
V:122, I:818 | 235 | patch(1) | eine diff-Datei auf ein Original anwenden |
dpatch
|
V:1, I:15 | 191 | dpatch(1) | Serien von Patches für Debian-Pakete verwalten |
diffstat
|
V:19, I:187 | 70 | diffstat(1) | eine Grafik der Veränderungen für eine diff-Datei erstellen |
patchutils
|
V:18, I:179 | 223 | combinediff(1) | einen kumulativen Patch aus zwei inkrementellen Patches erzeugen |
patchutils
|
V:18, I:179 | 223 | dehtmldiff(1) | ein Diff aus einer HTML-Seite extrahieren |
patchutils
|
V:18, I:179 | 223 | filterdiff(1) | Diffs aus einer Diff-Datei extrahieren oder entfernen |
patchutils
|
V:18, I:179 | 223 | fixcvsdiff(1) | von CVS erstellte Diff-Dateien, die patch(1) falsch interpretiert, reparieren |
patchutils
|
V:18, I:179 | 223 | flipdiff(1) | die Reihenfolge zweier Patches ändern |
patchutils
|
V:18, I:179 | 223 | grepdiff(1) | anzeigen, welche Dateien von einem Patch entsprechend einem regulären Ausdruck modifiziert werden |
patchutils
|
V:18, I:179 | 223 | interdiff(1) | Unterschiede zwischen zwei Unified-Diff-Dateien anzeigen |
patchutils
|
V:18, I:179 | 223 | lsdiff(1) | zeigen, welche Dateien von einem Patch verändert werden |
patchutils
|
V:18, I:179 | 223 | recountdiff(1) | Zähler und Offsets in vereinheitlichten Context-Diffs neu berechnen |
patchutils
|
V:18, I:179 | 223 | rediff(1) | Offsets und Zähler eines hand-editierten Diffs bereinigen |
patchutils
|
V:18, I:179 | 223 | splitdiff(1) | inkrementelle Patches aussortieren |
patchutils
|
V:18, I:179 | 223 | unwrapdiff(1) | Patches von fehlerhaften Zeilenumbrüchen befreien |
wiggle
|
V:0, I:0 | 166 | wiggle(1) | zurückgewiesene Patches anwenden |
quilt
|
V:4, I:41 | 711 | quilt(1) | Serien von Patches verwalten |
meld
|
V:16, I:41 | 3116 | meld(1) | vergleichen und zusammenführen von Dateien (GTK) |
dirdiff
|
V:0, I:2 | 144 | dirdiff(1) | Unterschiede zwischen Verzeichnissen anzeigen und zusammenführen |
docdiff
|
V:0, I:0 | 573 | docdiff(1) | zwei Dateien Wort-für-Wort / Buchstabe-für-Buchstabe vergleichen |
imediff2
|
V:0, I:0 | 34 | imediff2(1) | interaktives Zweiwege-Zusammenführungs-Werkzeug mit Vollbildschirmmodus |
makepatch
|
V:0, I:0 | 102 | makepatch(1) | erweiterte Patch-Dateien erzeugen |
makepatch
|
V:0, I:0 | 102 | applypatch(1) | erweiterte Patch-Dateien anwenden |
wdiff
|
V:5, I:78 | 643 | wdiff(1) | Wort-für-Wort-Unterschiede zwischen Textdateien anzeigen |
Die folgenden Prozeduren extrahieren die Unterschiede zwischen zwei
Quelldateien und erzeugen vereinheitlichte Diff-Dateien
"file.patch0
" bzw. "file.patch1
",
abhängig vom Speicherort der Dateien:
$ diff -u datei.alt datei.neu > datei.patch0 $ diff -u alt/datei neu/datei > datei.patch1
Die Diff-Datei (alternativ auch Patch-Datei genannt) wird genutzt, um eine Programmaktualisierung zu senden. Die Seite, die die Änderungen empfängt, wendet die Aktualisierung wie folgt an:
$ patch -p0 datei < datei.patch0 $ patch -p1 datei < datei.patch1
Hier eine Zusammenfassung der Versionskontrollsysteme (VCS) im Debian-System.
![]() |
Anmerkung |
---|---|
Wenn Sie neu sind auf dem Gebiet der VCS-Systeme, sollten Sie damit beginnen, Git zu lernen, das auf der Beliebtheitsskala schnell steigt. |
Tabelle 10.11. Liste von Werkzeugen für die Versionskontrolle
Paket | Popcon | Größe | Werkzeug | VCS-Typ | Erläuterung |
---|---|---|---|---|---|
cssc
|
V:0, I:2 | 1979 | CSSC | lokal | Klon von Unix SCCS (veraltet) |
rcs
|
V:4, I:22 | 539 | RCS | lokal | "Unix SCCS done right" (Unix SCCS richtig gemacht) |
cvs
|
V:6, I:55 | 4597 | CVS | fern | früherer Standard für fernes VCS |
subversion
|
V:31, I:144 | 4678 | Subversion | fern | "CVS done right" (CVS richtig gemacht), der neue De-Facto-Standard für fernes VCS |
git
|
V:279, I:436 | 33191 | Git | verteilt | schnelles DVCS in C (wird vom Linux-Kernel und anderen verwendet) |
mercurial
|
V:12, I:61 | 552 | Mercurial | verteilt | DVCS in Python und ein bisschen C |
bzr
|
V:4, I:22 | 73 | Bazaar | verteilt |
von tla beeinflußtes DVCS, geschrieben in Python (wird
verwendet von Ubuntu)
|
darcs
|
V:0, I:8 | 31349 | Darcs | verteilt | DVCS mit schlauer Algebra von Patches (langsam) |
tla
|
V:0, I:7 | 1011 | GNU arch | verteilt | DVCS hauptsächlich von Tom Lord (historisch) |
monotone
|
V:0, I:0 | 5815 | Monotone | verteilt | DVCS in C++ |
tkcvs
|
V:0, I:1 | 1498 | CVS, … | fern | GUI-Oberfläche von VCS-Depots (CVS, Subversion, RCS) |
gitk
|
V:8, I:49 | 1483 | Git | verteilt | GUI-Oberfläche von VCS-Depots (Git) |
VCS ist teilweise auch bekannt als Revision Control System (RCS) oder Software Configuration Management (SCM).
Verteilte Versionskontrollsysteme (DVCS) wie Git sind dieser Tage das System der Wahl. CVS und Subversion könnten nach wie vor nützlich sein, um die Aktivitäten einiger vorhandener quelloffener Programme zu vereinen.
Debian provides free VCS services via Debian Salsa service. It supports practically all VCSs. Its documentation can be found at https://wiki.debian.org/Salsa .
Es gibt einige Grundlagen für die Erstellung eines VCS-Archivs mit verteiltem Zugriff:
verwenden Sie "umask 002
" (lesen Sie dazu Abschnitt 1.2.4, „Steuerung der Berechtigungen für neu erzeugte Dateien: umask“);
alle Dateien im VCS-Archiv müssen der entsprechenden Gruppe angehören;
bei allen Verzeichnissen im VCS-Archiv sollte das Setzen der Gruppen-ID aktiviert sein (BSD-ähnliches Dateierzeugungs-Schema, lesen Sie Abschnitt 1.2.3, „Dateisystem-Berechtigungen“);
alle Benutzer, die das VCS-Archiv verwenden, müssen dieser Gruppe angehören.
Hier eine sehr vereinfachte Gegenüberstellung nativer VCS-Befehle, um einen groben Überblick zu ermöglichen. Eine typische Befehlssequenz könnte weitere Optionen und Argumente erfordern.
Tabelle 10.12. Gegenüberstellung nativer VCS-Befehle
Git | CVS | Subversion | Funktion |
---|---|---|---|
git init
|
cvs init
|
svn create
|
ein (lokales) Depot erstellen |
- |
cvs login
|
- | am fernen Depot anmelden |
git clone
|
cvs co
|
svn co
|
Herunterladen des fernen Depots als Arbeitsverzeichnis (Checkout) |
git pull
|
cvs up
|
svn up
|
Aktualisierung des Arbeitsverzeichnisses durch Abgleich mit dem fernen Depot |
git add .
|
cvs add
|
svn add
|
Datei(en) im Verzeichnisbaum zum VCS hinzufügen |
git rm
|
cvs rm
|
svn rm
|
Datei(en) im Verzeichnisbaum aus dem VCS entfernen |
- |
cvs ci
|
svn ci
|
Änderungen zum fernen Depot hochladen (Commit) |
git commit -a
|
- | - | Änderungen in das lokale Depot übernehmen (Commit) |
git push
|
- | - | das ferne mit dem lokalen Depot aktualisieren (durch Hochladen der Änderungen) |
git status
|
cvs status
|
svn status
|
den Status des Verzeichnisbaums aus dem VCS anzeigen |
git diff
|
cvs diff
|
svn diff
|
diff <referenzdepot> <verzeichnisbaum>: Unterschiede ermitteln zwischen <referenzdepot> und <verzeichnisbaum> |
git repack -a -d; git prune
|
- | - | das lokale Depot neu in ein einzelnes Pack verpacken |
gitk
|
tkcvs
|
tkcvs
|
grafische GUI-Anzeige eines VCS-Depots |
![]() |
Achtung |
---|---|
Der direkte Aufruf eines |
![]() |
Tipp |
---|---|
Wenn eine ausführbare Datei namens |
![]() |
Tipp |
---|---|
Grafische GUI-Werkzeuge wie tkcvs(1) und gitk(1) helfen Ihnen wirklich bei der Verfolgung der Vergangenheit von Dateien. Die Web-Oberfläche, die von vielen öffentlichen Archiven bereitgestellt wird, um die Depots mit einem Webbrowser zu durchsuchen, ist ebenfalls sehr nützlich. |
![]() |
Tipp |
---|---|
Git kann direkt mit verschiedenen VCS-Depots wie denen von CVS und
Subversion umgehen; es bietet über die |
![]() |
Tipp |
---|---|
Git enthält Befehle, für die es in CVS und Subversion keine equivalenten Entsprechungen gibt: "fetch", "rebase", "cherry-pick", … |
Git kann alles sowohl für die lokale wie auch für die ferne Quellcode-Verwaltung erledigen. Das bedeutet, dass Sie lokal alle Änderungen einpflegen können, ohne dazu eine Netzwerkverbindung zum fernen Depot zu benötigen.
Sie möchten vielleicht wie folgt verschiedene globale Konfigurationsoptionen
in "~/.gitconfig
" zur Verwendung durch Git setzen,
z.B. Name und E-Mail-Adresse:
$ git config --global user.name "Vorname Nachname" $ git config --global user.email ihr-name@example.com
Wenn Sie an CVS- oder Subversion-Befehle gewohnt sind, können Sie wie hier auch folgende Befehls-Alias setzen:
$ git config --global alias.ci "commit -a" $ git config --global alias.co checkout
Sie können wie folgt Ihre globale Konfiguration kontrollieren:
$ git config --global --list
Hier finden Sie weitere Informationen:
Handbuchseite: git(1)
(/usr/share/doc/git-doc/git.html
)
git-Benutzerhandbuch (engl.)
(/usr/share/doc/git-doc/user-manual.html
)
gittutorial: Einführung in git
(engl.) (/usr/share/doc/git-doc/gittutorial.html
)
gittutorial-2: Einführung in
git - Teil 2 (engl.)
(/usr/share/doc/git-doc/gittutorial-2.html
)
Anleitung für die alltägliche
git-Nutzung mit ungefähr 20 Befehlen (engl.)
(/usr/share/doc/git-doc/everyday.html
)
git für CVS-Benutzer (engl.)
(/usr/share/doc/git-doc/gitcvs-migration.html
)
Hier wird auch beschrieben, wie Sie einen Server identisch zu CVS einrichten und alte Daten aus CVS in Git extrahieren.
weitere im Web verfügbare Git-Ressourcen
Git Magic
(/usr/share/doc/gitmagic/html/index.html
)
Die git-gui(1)- und gitk(1)-Befehle machen die Git-Nutzung sehr einfach.
![]() |
Warnung |
---|---|
Nutzen Sie in der Tag-Zeichenkette keine Leerzeichen, auch wenn Werkzeuge
wie
gitk(1)
dies ermöglichen. Andere |
Selbst wenn bei Ihnen Upstream ein anderes VCS verwendet, könnte es eine gute Idee sein, für lokale Aktivitäten git(1) zu nutzen, da Sie Ihre lokale Kopie eines Quellcodebaums ohne Netzwerkverbindung zum Upstream-Depot verwalten können. Hier einige Pakete und Programme, die mit git(1) verwendet werden.
Tabelle 10.13. Liste von zu Git gehörigen Paketen und Befehlen
Paket | Popcon | Größe | Befehl | Beschreibung |
---|---|---|---|---|
git-doc
|
I:19 | 10733 | Nicht verfügbar | offizielle Dokumentation für Git |
gitmagic
|
I:1 | 719 | Nicht verfügbar | "Git Magic", eine einfacher verständliche Anleitung für Git |
git
|
V:279, I:436 | 33191 | git(7) | Git, das schnelle, skalierbare, verteilte Versionsverwaltungssystem |
gitk
|
V:8, I:49 | 1483 | gitk(1) | grafische Browser-Oberfläche mit Historie für Git-Depots |
git-gui
|
V:2, I:28 | 2210 | git-gui(1) | grafische Oberfläche (ohne Historie) für Git |
git-svn
|
V:2, I:27 | 995 | git-svnimport(1) | Daten aus Subversion in Git importieren |
git-svn
|
V:2, I:27 | 995 | git-svn(1) | bidirektionaler Einsatz von Subversion und Git |
git-cvs
|
V:0, I:13 | 1116 | git-cvsimport(1) | Daten aus CVS in Git importieren |
git-cvs
|
V:0, I:13 | 1116 | git-cvsexportcommit(1) | einen Commit aus Git in einen CVS-Checkout exportieren |
git-cvs
|
V:0, I:13 | 1116 | git-cvsserver(1) | CVS-Server-Emulator für Git |
git-email
|
V:0, I:13 | 800 | git-send-email(1) | eine Patch-Sammlung aus Git als E-Mail versenden |
stgit
|
V:0, I:1 | 1535 | stg(1) | Aufsatz für Git (Python) |
git-buildpackage
|
V:2, I:12 | 3863 | git-buildpackage(1) | das Debian-Paketieren mit Git automatisieren |
guilt
|
V:0, I:0 | 146 | guilt(7) | Aufsatz für Git (SH/AWK/SED/…) |
![]() |
Tipp |
---|---|
Bei
git(1)
führen Sie viele Commits (Übernahme der Änderungen ins Depot) in einem
lokalen Zweig (Branch) durch und nutzen später etwas wie " |
![]() |
Tipp |
---|---|
Falls Sie zu einem sauberen Arbeitsverzeichnis zurückkehren möchten, ohne
den aktuellen Status des Arbeitsverzeichnisses zu verlieren, können Sie
" |
Sie können einen Checkout eines Subversion-Depots unter
"svn+ssh://svn.example.org/project/modul/trunk
" in ein
lokales Git-Depot in "./dest
" ausführen, Änderungen
durchführen und diese dann zurück zum Subversion-Depot übergeben, z.B. wie
hier:
$ git svn clone -s -rHEAD svn+ssh://svn.example.org/project dest $ cd dest ... führen Sie Ihre Änderungen durch ... $ git commit -a ... weitere lokale Arbeiten mit git ... $ git svn dcommit
![]() |
Tipp |
---|---|
Dank der Verwendung von " |
Mit Git-Werkzeugen können Sie die Historie von
Konfigurationsdateien chronologisch aufzeichnen. Hier zur Übung ein
einfaches Beispiel zur Aufzeichnung der Inhalte von
"/etc/apt/
":
$ cd /etc/apt/ $ sudo git init $ sudo chmod 700 .git $ sudo git add . $ sudo git commit -a
Die Konfiguration mit einer Beschreibung einpflegen.
Machen Sie einige Änderungen an den Konfigurationsdateien.
$ cd /etc/apt/ $ sudo git commit -a
Übernehmen Sie dann die Konfiguration mit einer Beschreibung der Änderungen in das Git-Depot und fahren Sie mit Ihrer normalen Arbeit fort.
$ cd /etc/apt/ $ sudo gitk --all
Sie haben jetzt die vollständige Historie der Konfigurationsdateien vorliegen.
![]() |
Anmerkung |
---|---|
sudo(8)
wird benötigt, um jegliche Dateiberechtigungen von Konfigurationsdateien zu
bearbeiten. Bei Konfigurationsdaten von Benutzern können Sie das
|
![]() |
Anmerkung |
---|---|
Der Befehl " |
![]() |
Tipp |
---|---|
Falls Sie ein leistungsfähigeres Setup zur Aufzeichnung der Historie von
Konfigurationsdateien benötigen, schauen Sie sich das Paket
|
CVS is an older version control system before Subversion and Git.
![]() |
Achtung |
---|---|
Many URLs found in the below examples for CVS don't exist any more. |
Hier finden Sie weitere Informationen:
cvs(1)
"/usr/share/doc/cvs/html-cvsclient
"
"/usr/share/doc/cvs/html-info
"
"/usr/share/doc/cvsbook
"
"info cvs
"
Folgende Konfiguration erlaubt Commits (Übernehmen von Änderungen in das
CVS-Depot) nur durch Mitglieder der Gruppe "src
", und die
Administration von CVS nur durch Mitglieder der Gruppe
"staff
"; dies reduziert die Möglichkeit, den Server
versehentlich zu misskonfigurieren.
# cd /var/lib; umask 002; mkdir cvs # export CVSROOT=/srv/cvs/project # cd $CVSROOT # chown root:src . # chmod 2775 . # cvs -d $CVSROOT init # cd CVSROOT # chown -R root:staff . # chmod 2775 . # touch val-tags # chmod 664 history val-tags # chown root:src history val-tags
![]() |
Tipp |
---|---|
Sie sollten vielleicht das Erstellen von neuen Projekten einschränken, indem
Sie den Eigentümer des " |
Das Standard-CVS-Depot verweist auf "$CVSROOT
". Folgendes
richtet "$CVSROOT
" für lokalen Zugriff ein:
$ export CVSROOT=/srv/cvs/project
Many public CVS servers provide read-only remote access to them with account
name "anonymous
" via pserver service. For example,
Debian web site contents were maintained by webwml project via CVS at Debian alioth
service. The following was used to set up "$CVSROOT
" for
the remote access to this old CVS repository.
$ export CVSROOT=:pserver:anonymous@anonscm.debian.org:/cvs/webwml $ cvs login
![]() |
Anmerkung |
---|---|
Da pserver für Abhörattacken und Unsicherheiten bekannt ist, wird der entsprechende Schreibzugriff gewöhnlich durch die Systemadministratoren deaktiviert. |
The following was used to set up "$CVS_RSH
" and
"$CVSROOT
" for the remote access to the old CVS
repository by webwml project with SSH.
$ export CVS_RSH=ssh $ export CVSROOT=:ext:account@cvs.alioth.debian.org:/cvs/webwml
Sie können auch die Authentifizierung für SSH über einen öffentlichen Schlüssel aktivieren und so die Abfrage des Passworts unterbinden.
Erzeugen Sie einen neuen lokalen Quellcodebaum unter
"~/pfad/zu/modul1
", indem Sie dies eingeben:
$ mkdir -p ~/pfad/zu/modul1; cd ~/pfad/zu/modul1
Legen Sie Dateien in dem neuen Quellcodebaum unter
"~/pfad/zu/modul1
" an.
Importieren Sie es mit folgenden Parametern in CVS:
Modulname: "modul1
"
Vendor tag: "Haupt-Zweig
" (Markierung für den kompletten
Zweig)
Release tag: "initiale-Veröffentlichung
" (Markierung für
eine spezifische Version)
$ cd ~/pfad/zu/modul1 $ cvs import -m "Start von modul1" modul1 Haupt-Zweig initiale-Veröffentlichung $ rm -Rf . # optional
CVS überschreibt nicht die aktuelle Verzeichnisdatei, sondern ersetzt sie
durch eine andere. Daher sind Schreibrechte für ein Verzeichnis im Depot
kritisch. Führen Sie für jedes neue Modul von "modul1
" im
Depot unter "/srv/cvs/project
" folgendes aus, um den
korrekten Zustand falls nötig sicherzustellen:
# cd /srv/cvs/project # chown -R root:src modul1 # chmod -R ug+rwX modul1 # chmod 2775 modul1
Hier ein Beispiel eines typischen Arbeitsablaufs bei CVS:
Überprüfen Sie alle verfügbaren Module aus dem CVS-Projekt, auf das
"$CVSROOT
" zeigt:
$ cvs rls CVSROOT modul1 modul2 ...
Führen Sie einen Checkout von "modul1
" in das
Standard-Verzeichnis "./modul1
" durch:
$ cd ~/pfad/zu $ cvs co modul1 $ cd modul1
Führen Sie nötige Änderungen am Inhalt durch ...
Überprüfen Sie Ihre Änderungen über einen Befehl ähnlich zu "diff
-u [depot] [lokal]
":
$ cvs diff -u
Sie stellen fest, dass Sie eine Datei "file_to_undo
"
ernsthaft beschädigt haben, aber andere Dateien sind in Ordnung.
Überschreiben Sie die Datei "file_to_undo
" mit der
sauberen Kopie aus dem CVS, indem Sie folgendes ausführen:
$ cvs up -C file_to_undo
Sichern Sie den aktualisierten Quellcodebaum in das CVS-Depot:
$ cvs ci -m "Beschreibung der Änderungen"
Erzeugen Sie eine Datei "file_to_add
" und fügen Sie sie
zum CVS hinzu, wie folgt:
$ vi file_to_add $ cvs add file_to_add $ cvs ci -m "Datei file_to_add hinzugefügt"
Führen Sie die aktuellste Version aus dem CVS-Depot mit Ihrem lokalen Quellcode zusammen:
$ cvs up -d
Achten Sie auf Zeilen, die mit "C dateiname
" beginnen;
dies zeigt sich widersprechende Änderungen an.
Schauen Sie nach unverändertem Code in
".#dateiname.version
".
Suchen Sie nach "<<<<<<<
" und
">>>>>>>
" in den Dateien, bei denen
sich widersprechende Änderungen festgestellt wurden ("C
dateiname
").
Bearbeiten Sie die Dateien falls nötig, um Konflikte zu bereinigen.
Fügen Sie wie folgt eine Markierung (Tag)
"Veröffentlichung-1
" für die Version hinzu:
$ cvs ci -m "Letzte Änderungen für Veröffentlichung-1" $ cvs tag Veröffentlichung-1
Weitere Änderungen
Entfernen Sie die "Veröffentlichung-1
"-Markierung wie
folgt:
$ cvs tag -d Veröffentlichung-1
Fügen Sie die Änderungen wie folgt zum CVS hinzu:
$ cvs ci -m "Wirklich letzter Commit für Veröffentlichung-1"
Fügen Sie die "Veröffentlichung-1
"-Markierung erneut zum
aktualisierten CVS HEAD hinzu:
$ cvs tag Veröffentlichung-1
Erzeugen Sie einen Zweig mit einer fixen Zweig-Markierung
"initiale-Veröffentlichung-Fehlerkorrekturen
" aus der
originalen Version, auf die die Markierung
"initiale-Veröffentlichung
" zeigt, und führen Sie einen
Checkout in das Verzeichnis "~/pfad/zu/alt
" durch:
$ cvs rtag -b -r initiale-Veröffentlichung initiale-Veröffentlichung-Fehlerkorrekturen modul1 $ cd ~/pfad/zu $ cvs co -r initiale-Veröffentlichung-Fehlerkorrekturen -d alt modul1 $ cd alt
![]() |
Tipp |
---|---|
Verwenden Sie " |
Arbeiten Sie mit diesem lokalen Quellcodebaum, der die Markierung
"initiale-Veröffentlichung-Fehlerkorrekturen
" hat und der
auf der originalen Version beruht.
Arbeiten Sie selbst an diesem Zweig … bis jemand weiteres zu diesem
"initiale-Veröffentlichung-Fehlerkorrekturen
"-Zweig
hinzustößt.
Synchronisieren Sie die Dateien mit von anderen veränderten Dateien dieses Zweigs und erzeugen Sie dabei falls nötig auch neue Verzeichnisse, wie folgt:
$ cvs up -d
Bearbeiten Sie die Dateien falls nötig, um Konflikte zu bereinigen.
Fügen Sie die Änderungen wie folgt zum CVS hinzu:
$ cvs ci -m "in diesen Zweig hinzugefügt"
Aktualisieren Sie den lokalen Quellcodebaum bei HEAD von main; dabei wird
die fixe Zweig-Markierung entfernt ("-A
") und es wird
keine Tastatur-Expansion verwendet ("-kk
"):
$ cvs up -d -kk -A
Aktualisieren Sie den lokalen Quellcodebaum (Inhalt = HEAD von main), indem
Sie die Änderungen aus dem
"initiale-Veröffentlichung-Fehlerkorrekturen
"-Zweig (ohne
Verwendung von Tastatur-Expansion) zusammenführen:
$ cvs up -d -kk -j initiale-Veröffentlichung-Fehlerkorrekturen
Beheben Sie Konflikte mit einem Editor.
Fügen Sie die Änderungen wie folgt zum CVS hinzu:
$ cvs ci -m "initiale-Veröffentlichung-Fehlerkorrekturen zusammengeführt"
Erstellen Sie ein Archiv, wie folgt:
$ cd .. $ mv alt alt-modul1-korrekturen $ tar -cvzf alt-modul1-korrekturen.tar.gz alt-modul1-korrekturen $ rm -rf alt-modul1-korrekturen
![]() |
Tipp |
---|---|
Dem Befehl " |
![]() |
Tipp |
---|---|
Sie können einen Checkout von nur einem Unterverzeichnis von
" |
Tabelle 10.14. Erwähnenswerte Optionen für CVS-Befehle (als erste Argumente bei cvs(1) zu verwenden):
Option | Bedeutung |
---|---|
-n
|
Probelauf, ohne Wirkung |
-t
|
Meldungen ausgeben, die die einzelnen Schritte der CVS-Aktivitäten anzeigen |
Um die aktuellsten Dateien vom CVS zu bekommen, verwenden Sie
"tomorrow
", wie hier:
$ cvs ex -D tomorrow modulname
Fügen Sie wie folgt einen Modul-Alias "mx
" zum
CVS-Projekt (lokaler Server) hinzu:
$ export CVSROOT=/srv/cvs/project $ cvs co CVSROOT/modules $ cd CVSROOT $ echo "mx -a modul1" >>modules $ cvs ci -m "mx ist ein Alias für modul1" $ cvs release -d .
Jetzt können Sie einen Checkout von "modul1
" (Alias
"mx
") vom CVS in das "neu
"-Verzeichnis
durchführen:
$ cvs co -d neu mx $ cd neu
![]() |
Anmerkung |
---|---|
Um obiges Prozedere durchzuführen, sollten Sie die entsprechenden Dateirechte haben. |
Bei dem Checkout von Dateien vom CVS wird deren Ausführungs-Berechtigungs-Bit beibehalten.
Wenn Sie Berechtigungsprobleme bei der Ausführung von Dateien aus dem CVS
bemerken, z.B. bei der Datei "dateiname
", ändern Sie die
Berechtigungen im entsprechenden CVS-Depot wie hier, um die Probleme zu
beheben:
# chmod ugo-x dateiname
Subversion is an older version control system before Git but after CVS. It lacks tagging and branching features found in CVS and Git.
You need to install subversion
,
libapache2-mod-svn
and
subversion-tools
packages to set up a Subversion server.
Derzeit richtet das subversion
-Paket kein Depot ein, Sie
müssen es manuell erzeugen. Ein möglicher Ort für ein Depot ist
"/srv/svn/project
".
Erzeugen Sie ein Verzeichnis wie folgt:
# mkdir -p /srv/svn/project
Erzeugen Sie die Datenbank des Depots wie hier:
# svnadmin create /srv/svn/project
Wenn Sie nur über einen Apache2-Server auf das Subversion-Depot zugreifen wollen, muss das Depot lediglich für den WWW-Server schreibbar sein; führen Sie dazu dies aus:
# chown -R www-data:www-data /srv/svn/project
Fügen Sie folgendes zu
"/etc/apache2/mods-available/dav_svn.conf
" hinzu (oder
entfernen Sie die Kommentarzeichen, falls dies bereits auskommentiert
existiert), um den Zugriff auf das Depot über Benutzerauthentifizierung zu
erlauben:
<Location /project> DAV svn SVNPath /srv/svn/project AuthType Basic AuthName "Subversion repository" AuthUserFile /etc/subversion/passwd <LimitExcept GET PROPFIND OPTIONS REPORT> Require valid-user </LimitExcept> </Location>
Erzeugen Sie eine Benutzerauthentifizierungsdatei mit dem Kommando.
# htpasswd2 -c /etc/subversion/passwd irgendein-benutzername
Starten Sie Apache2 neu.
Ihr neues Subversion-Depot ist jetzt mit
svn(1)
über "http://localhost/project
" und
"http://example.com/project
" erreichbar (angenommen die
URL des Web-Servers ist "http://example.com/
").
Folgendes setzt für das Subversion-Depot den lokalen Zugriff durch eine
Gruppe, hier z.B. die Gruppe project
:
# chmod 2775 /srv/svn/project # chown -R root:src /srv/svn/project # chmod -R ug+rwX /srv/svn/project
Ihr neues Subversion-Depot ist mit
svn(1)
durch die Gruppe über "file:///localhost/srv/svn/project
"
oder "file:///srv/svn/project
" zugänglich, wenn die
lokalen Benutzer Mitglieder der Gruppe project
sind. Sie
müssen Befehle wie svn
, svnserve
,
svnlook
und svnadmin
unter
"umask 002
" ausführen, um den Gruppenzugriff
sicherzustellen.
Ein Subversion-Depot mit Gruppen-Zugriffsrechten ist via SSH über
"example.com:/srv/svn/project
" erreichbar, Sie können mit
svn(1)
über "svn+ssh://example.com:/srv/svn/project
"
daraufzugreifen.
Viele Projekte verwenden für Subversion Verzeichnisbäume ähnlich dem folgenden, um das Fehlen der Funktionalitäten Zweig (Branch) und Markierung (Tag) zu kompensieren:
----- modul1 | |-- zweige | |-- markierungen | | |-- veröffentlichung-1.0 | | `-- veröffentlichung-2.0 | | | `-- trunk | |-- datei1 | |-- datei2 | `-- datei3 | `-- modul2
![]() |
Tipp |
---|---|
Sie müssen den Befehl " |
Erzeugen Sie einen neuen lokalen Quellcodebaum unter
"~/pfad/zu/modul1
", indem Sie dies eingeben:
$ mkdir -p ~/pfad/zu/modul1; cd ~/pfad/zu/modul1
Legen Sie Dateien in dem neuen Quellcodebaum unter
"~/pfad/zu/modul1
" an.
Importieren Sie sie in Subversion mit folgenden Parametern:
Modulname: "modul1
"
Subversion Site-URL: "file:///srv/svn/project
"
Subversion-Verzeichnis: "modul1/trunk
"
Subversion-Tag: "modul1/tags/initiale-Veröffentlichung
"
$ cd ~/pfad/zu/modul1 $ svn import file:///srv/svn/project/modul1/trunk -m "Start von modul1" $ svn cp file:///srv/svn/project/modul1/trunk file:///srv/svn/project/modul1/tags/initiale-Veröffentlichung
Alternativ auch:
$ svn import ~/pfad/zu/modul1 file:///srv/svn/project/modul1/trunk -m "Start von modul1" $ svn cp file:///srv/svn/project/modul1/trunk file:///srv/svn/project/modul1/tags/initiale-Veröffentlichung
![]() |
Tipp |
---|---|
Sie können URLs wie " |
Hier ein Beispiel eines typischen Arbeitsablaufs mit Subversion und seinem nativen Client.
![]() |
Tipp |
---|---|
Client-Befehle, die durch das |
Überprüfen Sie wie folgt alle verfügbaren Module aus dem Subversion-Projekt,
auf das die URL "file:///srv/svn/project
" verweist:
$ svn list file:///srv/svn/project modul1 modul2 ...
Führen Sie einen Checkout von "modul1/trunk
" in ein
Verzeichnis "modul1
" durch:
$ cd ~/pfad/zu $ svn co file:///srv/svn/project/modul1/trunk modul1 $ cd modul1
Führen Sie nötige Änderungen am Inhalt durch ...
Überprüfen Sie Ihre Änderungen über einen Befehl ähnlich zu "diff
-u [depot] [lokal]
":
$ svn diff
Sie stellen fest, dass Sie eine Datei "file_to_undo
"
ernsthaft beschädigt haben, aber andere Dateien sind in Ordnung.
Überschreiben Sie die Datei "file_to_undo
" mit einer
sauberen Kopie aus Subversion:
$ svn revert file_to_undo
Sichern Sie den aktualisierten lokalen Quellcodebaum nach Subversion durch:
$ svn ci -m "Beschreibung der Änderungen"
Erzeugen Sie eine Datei "file_to_add
" und fügen Sie sie
zu Subversion hinzu:
$ vi file_to_add $ svn add file_to_add $ svn ci -m "Datei file_to_add hinzugefügt"
Führen Sie die aktuellste Version aus dem Subversion-Depot mit Ihrer lokalen Kopie zusammen:
$ svn up
Achten Sie auf Zeilen, die mit "C dateiname
" beginnen;
dies zeigt sich widersprechende Änderungen an.
Suchen Sie nach unveränderten Code-Teilen, z.B. in
"filename.r6
", "filename.r9
" und
"filename.mine
".
Suchen Sie nach "<<<<<<<
" und
">>>>>>>
" in den Dateien, bei denen
sich widersprechende Änderungen festgestellt wurden ("C
dateiname
").
Bearbeiten Sie die Dateien falls nötig, um Konflikte zu bereinigen.
Fügen Sie wie folgt eine Markierung (Tag)
"Veröffentlichung-1
" für die Version hinzu:
$ svn ci -m "Letzter Commit für Veröffentlichung-1" $ svn cp file:///srv/svn/project/modul1/trunk file:///srv/svn/project/modul1/tags/Veröffentlichung-1
Weitere Änderungen
Entfernen Sie die "Veröffentlichung-1
"-Markierung wie
folgt:
$ svn rm file:///srv/svn/project/modul1/tags/Veröffentlichung-1
Sichern Sie Ihre Änderungen in das Subversion-Depot:
$ svn ci -m "Wirklich letzter Commit für Veröffentlichung-1"
Fügen Sie die "Veröffentlichung-1
"-Markierung erneut aus
dem aktualisierten Subversion-HEAD von trunk hinzu:
$ svn cp file:///srv/svn/project/modul1/trunk file:///srv/svn/project/modul1/tags/Veröffentlichung-1
Erzeugen Sie einen neuen Zweig mit dem Pfad
"modul1/branches/initiale-Veröffentlichung-Fehlerkorrekturen
"
aus der originalen Version, auf die der Pfad
"modul1/tags/initiale-Veröffentlichung
" zeigt, und
sichern Sie ihn in das "~/pfad/zu/alt
"-Verzeichnis, wie
hier:
$ svn cp file:///srv/svn/project/modul1/tags/initiale-Veröffentlichung file:///srv/svn/project/modul1/branches/initiale-Veröffentlichung-Fehlerkorrekturen $ cd ~/pfad/zu $ svn co file:///srv/svn/project/modul1/branches/initiale-Veröffentlichung-Fehlerkorrekturen alt $ cd alt
![]() |
Tipp |
---|---|
Verwenden Sie " |
Arbeiten Sie weiter an dem lokalen Quellcodebaum, der auf
"initiale-Veröffentlichung-Fehlerkorrekturen
" verweist
und der auf der originalen Version beruht.
Arbeiten Sie selbst an diesem Zweig … bis jemand weiteres zu diesem
"initiale-Veröffentlichung-Fehlerkorrekturen
"-Zweig
hinzustößt.
Synchronisieren Sie die Dateien in diesem Zweig, die von anderen modifiziert wurden, wie hier:
$ svn up
Bearbeiten Sie die Dateien falls nötig, um Konflikte zu bereinigen.
Sichern Sie Ihre Änderungen in das Subversion-Depot:
$ svn ci -m "In diesen Zweig gesichert"
Aktualisieren Sie den lokalen Baum mit HEAD von trunk wie folgt:
$ svn switch file:///srv/svn/project/modul1/trunk
Aktualisieren Sie den lokalen Baum (Kontext = HEAD von trunk), indem Sie ihn
mit dem Zweig
"initiale-Veröffentlichung-Fehlerkorrekturen
"
zusammenführen:
$ svn merge file:///srv/svn/project/modul1/branches/initiale-Veröffentlichung-Fehlerkorrekturen
Beheben Sie Konflikte mit einem Editor.
Sichern Sie Ihre Änderungen in das Subversion-Depot:
$ svn ci -m "initiale-Veröffentlichung-Fehlerkorrekturen zusammengeführt"
Erstellen Sie ein Archiv, wie folgt:
$ cd .. $ mv alt alt-modul1-korrekturen $ tar -cvzf alt-modul1-korrekturen.tar.gz alt-modul1-korrekturen $ rm -rf alt-modul1-korrekturen
![]() |
Tipp |
---|---|
Sie können URLs wie " |
![]() |
Tipp |
---|---|
Sie können einen Checkout von nur einem Unterverzeichnis von
" |
Tabelle 10.15. Erwähnenswerte Optionen für Subversion-Befehle (als erste Argumente bei svn(1)) zu verwenden):
Option | Bedeutung |
---|---|
--dry-run
|
Probelauf, ohne Wirkung |
-v
|
detaillierte Meldungen der svn-Aktivitäten anzeigen |