Meine Arch Linux Installation

In dieser Anleitung erkläre ich, wie ich mein Arch Linux am liebsten installiere. Dabei sind folgende Punkte gegeben:

Multi-Boot Fähig
Stabil für Umzüge von Legacy zu UEFI
Btrfs und Subvolume
Verschlüsselung mit dm-crypt
Gnome
NetworkManager
Bootloader Konfigurationen mit UUID
GPT Partitionen

Vorbereitung

Wir gehen hier bei, davon aus das wir von einem Arch Linux USB-Stick gebootet haben und die erste Festplatte sda ist.

Wir laden uns erst mal das richtige Tastatur-Layout (In diesem Fall de-latin1).
```
loadkeys de
loadkeys de-latin1
```
Da wir eine Verschlüsselung einsetzten werden, benötigen wir dm-crypt.
```
modprobe dm-crypt
```

Partitionierung der Festplatte

Wie oben gesagt, gehe ich hier von sda als Laufwerk aus, auf dem wir alles Installieren wollen. Auflisten der Verbauten Laufwerke und damit auch ermitteln, welches sein Installations-Laufwerk ist, kann man mit folgendem Befehl:
```
fdisk -l
```
Nun erstellen wir unsere Partitionen. Damit wir kompatibel zu UEFI bleiben, setzten wir GPT ein. Dies erfordert aber für den Bootloader Grub eine extra Partition, am Anfang wenn dieser im Legacy Mode Booten soll. Ersteinmal erstellen wir dafür nun eine leere GPT Tabelle mit sgdisk:
```
sgdisk -o /dev/sda
```
Bei einer Festplatte mit GPT ist grub auf einen Reservebereich am Anfang der Festplatte angewiesen wenn kein UEFI genutzt wird. Diesen erstellen wir als erstes.
```
sgdisk -a 2048 -n 1::+1024K -c 1:"BIOS Boot Partition" -t 1:ef02 /dev/sda
```
Nun erstellen wir die (U)EFI-Boot Partition mit einer Größe von 1 Gigabyte. Dies sollte auch Langfristig für einige hinterlegte Kernel reichen.
```
sgdisk -a 2048 -n 2::+1G -c 2:"EFI Boot Partition" -t 2:ef00 /dev/sda
```
Bevor wir den Rest der Festplatte, dem System geben, brauchen wir noch den swap. Die Größe ist bei mir, gleich der Kapazität des RAMs. In diesem Fall 8 Gigabyte.
```
sgdisk -a 2048 -n 3::+8G -c 3:"Linux swap" -t 3:8200 /dev/sda
```
Den Rest geben wir für das verschlüsselte dm-crypt Volume frei, auf dem wir später btrfs einrichten.
```
sgdisk -a 2048 -n 4:: -c 4:"Linux filesystem" -t 4:8300 /dev/sda
```

Einrichtung der Verschlüsselung

Nun sorgen wir dafür das unsere Partition für das Linux verschlüsselt ist. Nach dem Eingeben des Befehls cryptsetup, müsst ihr in Großbuchstaben yes eingeben. Damit bestätigen ihr, das ihr auch Sicher seit was ihr macht. Anschließend dürft ihr eure Passphrase eingeben.
```
cryptsetup -c aes-xts-plain64 -y -s 512 luksFormat /dev/sda4
```
Damit wir nun alle Partitionen mit den Filesystemen Formatieren können, müssen wir erst einmal unsere, eben verschlüsselte Partition entschlüsseln. Als Namen für die entschlüsselte Partition nehmen wir hier luks0. Nach dem ihr eure Passphrase eingegeben habt, findet ihr eure entschlüsselte Partition unter /dev/mapper/luks0.

cryptsetup luksOpen /dev/sda4 luks0

Erstellung der Dateisysteme

Für die Möglichkeit, später auch via UEFI booten zu können, muss auf sda2 ein FAT 32 Dateisystem erstellt werden.
```
mkfs.fat -F 32 -n EFIBOOT /dev/sda2
```
Den SWAP, welchen wir später dynamisch verschlüsseln, formatieren wir mit Befehl mkswap.
```
mkswap /dev/sda3
```
Unser zukünftiges btrfs Dateisystem erstellen wir mit dem Befehl mkfs.btrfs.
```
mkfs.btrfs /dev/mapper/luks0
```

Btrfs Anpassungen für Multiboot

Vorwort

Damit wir später verschiedene Systeme booten können und unser Arch Linux davon nicht betroffen ist, installieren wir dieses später in ein sogenanntes btrfs subvolume. Damit der Home Ordner von uns aber bspw. auch in anderen Systemen genutzt werden kann, erhält auch dieser ein eigenes subvolume. In den folgenden Schritten, erstellen wir diese und nutzten gleich einige spezielle mount Optionen von btrfs. In diesem Fall nutzte ich die Folgenden:

compress=zlib #Btrfs soll Versuchen Dateien mit zlib zu Komprimieren.
space_cache #Btrfs legt sich einen Cache mit Informationen zu dem freien Speicherblöcken an, um beim Schreiben schneller zu werden.
inode_cache #Hierdurch werden frei gewordene inode auch wieder vergeben.
autodefrag #Btrfs versucht Dateien, in denen zufällige Schreib Operationen durchgeführt werden, zu erkennen.

Als erstes Mounten wir nun unserer Btrfs mit den erklärten Optionen:

mount -o compress=zlib,space_cache,inode_cache,autodefrag /dev/mapper/luks0 /mnt

Anschließend erstellen wir uns unsere Subvolumes. Dafür ist der Befehl btrfs vorhanden.
```
btrfs subvolume create /mnt/@arch
btrfs subvolume create /mnt/@home
```
Nach dem wir damit Fertig sind unmounten wir dies:
```
umount /mnt
```

Installationsmountpoints einhängen

Hier bereiten wir nun unter /mnt die Mounts so vor war dir dort Arch Linux installieren können.

Einhängen des subvolume @arch vom btrfs auf dem luks0 Volume unter /mnt.

mount -o compress=zlib,space_cache,inode_cache,autodefrag,subvol=@arch /dev/mapper/luks0 /mnt

Erstellen der Ordner für home und boot unter /mnt, damit wir diese als Mountpoint nutzten können
```
mkdir /mnt/{home,boot}
```

Nun hängen wir das @home subvolume vom btrfs auf /mnt/home ein

mount -o compress=zlib,space_cache,inode_cache,autodefrag,subvol=@home /dev/mapper/luks0 /mnt/home

Zum Schluss hängen wir noch unsere boot Partition auf /mnt/boot ein.
```
mount /dev/sda2 /mnt/boot
```

Wir brauchen Internet

Ihr könnt jetzt entweder ein Ethernet Kabel anschließen, oder mit wifi-menu eine WLAN Verbindung herstellen. Sobald ihr Internet habt, aktualisiert Ihr die Systemquellen mit dem folgendem Befehl:

pacman -Sy

Installation von Arch Linux

Nun Installieren wir unser eigentliches Arch Linux und richten die notwendigen Konfigurationen ein.

Installation der Pakete für Arch unter /mnt
```
pacstrap /mnt base base-devel
```
Erstellung der fstab Datei mit UUIDs zur Platten Identifikation
```
genfstab -Up /mnt > /mnt/etc/fstab
```
Für die weiteren Schritte müssen wir mit chroot in das zukünftige System einsteigen.
```
arch-chroot /mnt/
```

Nun aktualisieren wir auch hier die Quellen und Installieren weitere gewünschte Pakete mit pacman.

pacman -Sy

pacman -S wpa_supplicant dialog intel-ucode gnome gnome-extra networkmanager dnsmasq btrfs-progs grub efibootmgr dosfstools gptfdisk

In den folgenden Abschnitt steht alles was in Großbuchstaben geschrieben ist und mit zwei $ Anfängt, für einen Namen den ihr euch aussuchen dürft.

echo $$HOSTNAME > /etc/hostname
echo LANG=de_DE.UTF-8 > /etc/locale.conf
echo LC_COLLATE=C >> /etc/locale.conf
echo LANGUAGE=de_DE >> /etc/locale.conf
echo KEYMAP=de-latin1 > /etc/vconsole.conf
echo FONT=lat9w-16 >> /etc/vconsole.conf
ln -sf /usr/share/zoneinfo/Europe/Berlin /etc/localtime

Nun müssen in der Datei /etc/locale.gen folgende Zeilen auskommentiert werden.
```
de_DE.UTF-8 UTF-8
de_DE ISO-8859-1
de_DE@euro ISO-8859-15
```
Anschließend den Befehl locale-gen ausführen.
Nun müssen wir, für die Compilierung des Kernel hinterlegen, das die notwendigen „HOOKS“ für die Entschlüsselung geladen werden.
```
sed -i 's/HOOKS=.*$/HOOKS=(base udev autodetect modconf block keyboard keymap encrypt filesystems fsck shutdown)/' /etc/mkinitcpio.conf
```
Jetzt können wir den Linux-Kernel Compilieren.
```
mkinitcpio -p linux
```

Nun müssen wir den grub bootloader anpassen, damit er das luks Volume beim Booten entschlüsselt kann.

vUUID=$(blkid | grep sda4 | egrep -o ' UUID=\"[0-9a-z\-]*' | egrep -o '[0-9a-z\-]*')
sed -i 's/GRUB_CMDLINE_LINUX=.*$/GRUB_CMDLINE_LINUX="cryptdevice=UUID='$vUUID':luks0"/' /etc/default/grub
grub-mkconfig -o /boot/grub/grub.cfg

Nun können wir den bootloader auf die Festplatte Schreiben
```
grub-install /dev/sda
```

Letzte Schritte vor dem Reboot

Root Password setzten.
```
passwd
```

Bis dato haben wir noch nicht den swap genutzt oder eingerichtet. Dieser wird nun via crypttab eingerichtet und beim kommenden Booten automatisch Verschlüsselt.

vSwapUUID=$(blkid | grep sda3 | egrep -o ' UUID=\"[0-9a-z\-]*' | egrep -o '[0-9a-z\-]*')
echo "swap UUID=${vSwapUUID} /dev/urandom swap,cipher=aes-cbc-essiv:sha256,size=256" >> /etc/crypttab

Anlegen des eigenen Benutzers und dessen Kennwort festlegen.
```
useradd -m -g users -s /bin/bash $$USERNAME
```
Nun aktivieren wir noch über systemd den gdm und NetworkManager.
```
systemctl enable NetworkManager gdm
```
Nun könnt ihr mit ^D arch-chroot verlassen und nach dem Umount von /mnt das System rebooten.
```
^d
umount -R /mnt
reboot
```