Day 5 - Week 7 Comprehensive Review: The Big Picture of Backup and System Administration

📌 Key Takeaways

• Pattern ① running through the week: almost every administration tool has a 2-tier structure of "low-level single tool ↔ high-level automation tool". rpm↔yum, dpkg↔apt, insmod↔modprobe.
• The low level handles a single target directly and cannot resolve dependencies, while the high level consults repositories and dependency maps to handle things automatically. On the exam, the answer is usually the high level.
• Pattern ②: backup tools split by operating layer — file level (tar, rsync, cpio), file system level (dump/restore, levels 0 to 9), block level (dd).
• rsync is the standard for incremental synchronization that transfers only what changed (-a preserve · -v verbose · -z compress · --delete).
• dd wipes out your data entirely if you swap if/of. dump is for the ext family only (for xfs, use xfsdump).

Backup — tar·dump·restore·rsync·dd·cpio

• Backup means making copies to guard against data loss.
• Each tool has a different operating layer and purpose — this layer is the criterion for choosing a tool.

tar -czvf backup.tar.gz /home/user      # a directory into a compressed archive (most common)
tar -xzvf backup.tar.gz                  # restore (extract)
rsync -av /src/ /backup/                 # incremental sync (changed parts only)
rsync -avz /src/ user@host:/backup/      # compressed transfer to a remote host (z)
dd if=/dev/sda of=/backup/disk.img       # clone a disk whole, block by block
dump -0u -f /backup/full.dump /dev/sda1  # file system level 0 (full) backup
restore -rf /backup/full.dump            # restore a dump backup
find /home | cpio -ov > backup.cpio      # archive combined with find

💡 Concept: Backup tools must be understood by operating layer. tar/rsync/cpio work at the file level, picking files and directories to back up. dump/restore work at the file system level and support levels (0 = full, 1 to 9 = incremental). dd works at the lowest block (device) level, cloning the disk bit for bit including free space — which is why it is used for whole-disk images and cloning boot disks. A different layer means a different use.

The strength of rsync is incremental transfer. The first time it copies everything, but from then on it transfers only changed files and changed blocks, saving a great deal of time and bandwidth. -a (archive, preserves permissions, timestamps, links), -v (verbose), -z (compress during transfer), and --delete (also delete from the backup the files that no longer exist in the source) are the key options. It is the de facto standard for remote backup. Be careful: a trailing slash on a path (/src/) means "the contents inside the directory", which changes the result.

⚠️ Trap: dd is as dangerous as it is powerful. If you swap if (input file) and of (output file), it overwrites the disk you meant to back up with an empty image and destroys the data entirely — hence the nickname "data destroyer". Also, dump is specialized for ext2/3/4 and cannot be used on xfs and others (for xfs, use xfsdump). Each tool supports different file systems.

# Try it yourself — backup practice (in a safe directory)
mkdir -p /tmp/src /tmp/dst
echo "hello" > /tmp/src/a.txt
tar -czvf /tmp/backup.tar.gz /tmp/src      # tar backup
tar -tzvf /tmp/backup.tar.gz               # check contents (without extracting)
rsync -av /tmp/src/ /tmp/dst/              # rsync synchronization
echo "world" >> /tmp/src/a.txt
rsync -av /tmp/src/ /tmp/dst/              # second run: only what changed is transferred

Tying the Week Together — Threading It with the 2-Tier Structure

• Gathering this week's key points into a single table makes the "low-level ↔ high-level" pattern vivid.

All three rows share the same principle: "the low level handles a single file/target directly and cannot resolve dependencies automatically, while the high level consults repositories/dependency maps to handle things automatically". rpm -ivh stopping on a dependency error, dpkg -i leaving things in a "not configured" state, insmod failing with "Unknown symbol" — all have the same reason (manual dependencies). That's why the answer in real work and on the exam is usually a high-level tool.

Source Install and Kernel Compile — Same make, Different Results

Both build with make, but the configuration method differs. For ordinary source, ./configure surveys the system and creates the Makefile, while for the kernel you select features yourself (*/M/excluded) with make menuconfig to create .config. The kernel's installation also has two branches — modules with make modules_install (→/lib/modules), and the kernel image with make install (→/boot + GRUB). Libraries split into dynamic (.so, managed with ldd/ldconfig) and static (.a).

Where Devices Meet Backup — Why dd Handles Blocks

Day 4's "block device (b) vs character device (c)" ties directly to backup. The reason dd can clone a whole disk is that a disk is a block device, so random access in block units is possible. Character devices (terminals, keyboards) are streams and cannot be cloned into an image. So dd if=/dev/sda (a block device) works, but dd if=/dev/tty0 (a character device) has no meaning as a disk image backup. Device type → possible backup method connect in a single line.

The age of the backup tools shows their design philosophy. dump/restore and dd are classics from 1970s Unix, handling file systems and devices directly. tar (tape archive) was originally built to back up to magnetic tape, which is why "tape" remains in its name. cpio is also a tape tool from the same era. rsync is a relative newcomer that appeared in 1996, and it made "transfer only the changed parts" its core, fitting the network era. The older the tool, the lower the layer it aims at (blocks, file systems, tape); the newer the tool, the more it aims at efficient network synchronization.

📖 Glossary

• Low-level ↔ high-level 2-tier structure : A pairing of a tool that handles a single target directly and a tool that handles dependencies and repositories automatically. The backbone running through this week.
• Automatic dependency resolution : The ability to find and install/load other required packages or modules first. Only high-level tools do it.
• tar : Short for "tape archive". The most common backup tool for bundling and compressing files and directories.
• rsync : An incremental sync tool that transfers only the changed parts. The de facto standard for remote backup.
• Incremental backup : A method that, instead of taking a full copy again, stores only what changed since the last backup. It saves time and space.
• dump levels 0 to 9 : 0 is a full backup, and 1 to 9 are incremental stages that contain only the changes since a lower-level backup.
• dd's if / of : Input file / output file. If swapped, the source is overwritten and the data disappears.
• cpio : A classic tool that takes the output of find and makes an archive. Used for selective backup.
• Operating layer : The unit a tool handles — file / file system / block (device). A different layer means a different use.
• --delete : An rsync option that also deletes from the destination the files that don't exist in the source, creating an exact mirror.