Installation

Vom Hoster gibt es keine FreeBSD Images mehr. Großer Schock!

Das Rescue System hat OpenZFS und QEMU am Start. Dann aus dem alten Host und Zeug noch Wissen gezogen.

Der Plan: mfsbsd mittels QEMU starten, die Festplatten durchreichen und von Hand da FreeBSD rein installieren.

Hintergrund

Im Server sind 2x 10TB Festplatten verbaut. Will große Dateien hosten und Thick Jails laufen lassen. Deshalb keine SSDs. Habe einfach auch keine Lasten die schnellen Disk-IO benötigen.

Auch werde ich kein EFI aufsetzen. Sind mir zu viele bewegliche Teile die kaputt gehen können. Ob der Bootloader fancy aussieht ist im Rack egal (Jajaja, Kernelmodule, ich weiß…).

Die zwei Festplatten bekommen einen Mirror verpasst:

Name	Size	Type
`boot0`, `boot1`	`512K`	`freebsd-boot`	2x einzeln	🔓
`swap0`, `swap1`	`16G`	`freebsd-swap`	gmirror eli	🔑
`core0`, `core1`	`64G`	`freebsd-zfs`	fürs system	🔓
`virt0`, `virt1`	`1024G`	`freebsd-zfs`	für jails	🔑
`data0`, `data1`	rest	`freebsd-zfs`	für files	🔑

Bootstrapping

Server ins Rescue-System booten.
Verbinden mit ssh -o StrictHostKeyChecking=no…
Linux Kram:
- apt update
- apt install tmux htop curl

mfsbsd im App-Store laden:

curl -O https://mfsbsd.vx.sk/files/iso/14/amd64/mfsbsd-14.1-RELEASE-amd64.iso

Ab jetzt sollten wir in tmux sein…

qemu-system-x86_64 \
  -net nic -net user,hostfwd=tcp::1022-:22 -m 2048M -enable-kvm \
  -cpu host,+nx -M pc -smp 2 -vga std -k en-us \
  -cdrom ./mfsbsd-14.1-RELEASE-amd64.iso \
  -device virtio-scsi-pci,id=scsi0 \
  -drive file=/dev/sda,if=none,format=raw,discard=unmap,aio=native,cache=none,id=n0 \
  -device scsi-hd,drive=n0,bus=scsi0.0 \
  -drive file=/dev/sdb,if=none,format=raw,discard=unmap,aio=native,cache=none,id=n1 \
  -device scsi-hd,drive=n1,bus=scsi0.0 \
  -boot once=d -monitor stdio

Neue console in tmux, und ssh -p 1022 root@localhost. Passwort ist mfsroot.

Partitionieren

Die zwei Platten haben die Devices /dev/da0 & /dev/da1 bekommen.

Für das momentane System zfs laden und 4K Sektoren erzwingen:

kldload zfs

sysctl vfs.zfs.min_auto_ashift=12

Bootsektoren der Platten nullen:

dd count=2 if=/dev/zero of=/dev/da0
dd count=2 if=/dev/zero of=/dev/da1

Partitionstabelle anlegen:

gpart create -s GPT da0
gpart create -s GPT da1

Die Partitionen (nach Tabelle oben) erstellen:

gpart add -a 4k -t freebsd-boot -s 512K -l boot0 da0
gpart add -a 4k -t freebsd-boot -s 512K -l boot1 da1

gpart add -a 4k -t freebsd-swap -s 16G -l swap0 da0
gpart add -a 4k -t freebsd-swap -s 16G -l swap1 da1

gpart add -a 4k -t freebsd-zfs -s 64G -l core0 da0
gpart add -a 4k -t freebsd-zfs -s 64G -l core1 da1

gpart add -a 4k -t freebsd-zfs -s 1024G -l virt0 da0
gpart add -a 4k -t freebsd-zfs -s 1024G -l virt1 da1

gpart add -a 4k -t freebsd-zfs -l data0 da0
gpart add -a 4k -t freebsd-zfs -l data1 da1

Unter /dev/gpt sollten alle Partitionen als Devices vorhanden sein.

Boot Partition

Partitionen markieren:

gpart set -a bootme -i 1 da0
gpart set -a bootme -i 1 da1

Bootloader kommt beim chroot ins installierte System. Stay tuned.

Swap

Es reicht hier den Mirror zu erstellen.

gmirror label swap gpt/swap0 gpt/swap1

In das Ziel-System kommt später noch ein Eintrag in die fstab.

Pools & Datasets

Das Installations-Target ist /mnt.

Für das System selbst – `core`

zpool create \
  -f -m none \
  -o cachefile=/boot/zfs/zpool.cache \
  -o altroot=/mnt \
  -O compression=lz4 \
  -O atime=off \
  core gpt/core0 gpt/core1

zfs create -o mountpoint=none core/ROOT
zfs create -o mountpoint=/ core/ROOT/default

zfs create -o mountpoint=/usr -o canmount=off core/usr
zfs create -o setuid=off core/usr/ports
zfs create core/usr/home
zfs create core/usr/local
zfs create core/usr/obj
zfs create core/usr/src

zfs create -o mountpoint=/var -o canmount=off core/var
zfs create -o atime=on core/var/mail
zfs create -o setuid=off -o exec=off core/var/audit
zfs create -o setuid=off -o exec=off core/var/crash
zfs create -o setuid=off -o exec=off core/var/log
zfs create -o setuid=off core/var/tmp
zfs create core/var/db

Boot Environment setzen:

zpool set bootfs=core/ROOT/default core

Für die Jails – `virt`

zpool create \
  -f -m none \
  -o cachefile=/boot/zfs/zpool.cache \
  -o altroot=/mnt \
  -O compression=lz4 \
  -O atime=off \
  virt gpt/virt0 gpt/virt1

zfs create -o mountpoint=none virt/ROOT

zfs create -o mountpoint=/usr/jails virt/jails
zfs create virt/jails/proxy
zfs create virt/jails/asset
zfs create virt/jails/thing

Generischer Speicherplatz – `data`

zpool create \
  -f -m none \
  -o cachefile=/boot/zfs/zpool.cache \
  -o altroot=/mnt \
  -O compression=lz4 \
  -O atime=off \
  data gpt/data0 gpt/data1

zfs create -o mountpoint=none data/ROOT

zfs create -o mountpoint=/var/data/share -o setuid=off data/share
zfs create -o setuid=on data/share/certs
zfs create data/share/sync

zfs create -o mountpoint=/var/data/store data/store
zfs create -o atime=on data/store/keys

System Installieren

Wir brauchen die zwei Disketten in Laufwerk A: & B::

fetch https://download.freebsd.org/releases/amd64/14.2-RELEASE/MANIFEST \
  -o /mnt/var/data/store/MANIFEST
fetch https://download.freebsd.org/releases/amd64/14.2-RELEASE/base.txz \
  -o /mnt/var/data/store/base.txz
fetch https://download.freebsd.org/releases/amd64/14.2-RELEASE/kernel.txz \
  -o /mnt/var/data/store/kernel.txz

# check
grep "$(sha256 -q /mnt/var/data/store/base.txz)" /mnt/var/data/store/MANIFEST
grep "$(sha256 -q /mnt/var/data/store/kernel.txz)" /mnt/var/data/store/MANIFEST

Auspacken:

tar -C /mnt -xf /mnt/var/data/store/base.txz
tar -C /mnt -xf /mnt/var/data/store/kernel.txz

Das wars. Feierabend!

Konfigurieren

Die boot/loader.conf:

cat << LOL >> /mnt/boot/loader.conf
cryptodev_load="YES"
geom_eli_load="YES"
geom_mirror_load="YES"
zfs_load="YES"

vfs.root.mountfrom="zfs:core/ROOT/default"
kern.geom.label.disk_ident.enable="0"
kern.geom.label.gptid.enable="0"
security.bsd.allow_destructive_dtrace="0"

fdescfs_load="YES"
nullfs_load="YES"
tmpfs_load="YES"
LOL

Eine fstab im Zielsystem erzeugen:

cat << LOL >> /mnt/etc/fstab
tmpfs                   tmp     tmpfs   rw,mode=1777  0   0
/dev/mirror/swap.eli    none    swap    sw            0   0
LOL

Berechtigungnen für /tmp setzen:

chmod 1777 /mnt/tmp
chmod 1777 /mnt/var/tmp

Die Zeitzone verlinken (Ziel existiert noch nicht, bzw. unter altroot /mnt):

ln -s /usr/share/zoneinfo/Europe/Berlin /mnt/etc/localtime

Home-Folder verlinken (Ziel existiert hier auch noch nicht wegen altroot):

ln -s /usr/home /mnt/home

Und die rc.conf:

cat << LOL >> /mnt/etc/rc.conf
# Filesystem
zfs_enable="YES"
dumpdev="AUTO"

# Network
hostname="machine"
ifconfig_em0="DHCP"
ifconfig_em0_ipv6="inet6 accept_rtadv"
resolv_enable="NO"

netwait_enable="YES"

# Daemons
syslogd_flags="-ss"
powerd_enable="YES"
smartd_enable="YES"

sshd_enable="YES"
ntpd_enable="YES"
ntpd_sync_on_start="YES"

sendmail_enable="NO"
sendmail_submit_enable="NO"
sendmail_outbound_enable="NO"
sendmail_msp_queue_enable="NO"
LOL

Anmerkung der Redaktion: Der Name vom Interface kann anders sein. Für mich ist es igb0. Es lohnt sich auch mal Notizen zu machen was für eine Netzwerk-Config das Rescue-System per DHCP bekommen hat (z.B. Gateway-Addresse).

Kernel Zeug:

cat << LOL >> /mnt/etc/sysctl.conf
# force 4K sectors
vfs.zfs.min_auto_ashift=12
# hardening
security.bsd.unprivileged_read_msgbuf=0
security.bsd.unprivileged_proc_debug=0
kern.randompid=1
LOL

DNS wäre auch ganz nett:

cat << LOL >> /mnt/etc/resolv.conf
nameserver 2620:fe::fe
nameserver 2620:fe::9

nameserver 149.112.112.112
nameserver 9.9.9.9
LOL

Changeroot

Vorbereiten:

mount -t devfs devfs /mnt/dev
mount -t tmpfs tmpfs /mnt/tmp

Wir können das System erstmalig nutzen:

chroot /mnt

Symlinks checken:
- Passt /home nach /usr/home?
- Zeigt /etc/localtime nicht ins leere?
Root Passwort mit passwd setzen.
User mit adduser erstellen (in Gruppe wheel einladen).
pkg zum Leben erwecken…
- pkg info -ao
- pkg install sudo
  - In der /usr/local/etc/suoders diese Zeile auskommentieren:
```
%wheel ALL=(ALL:ALL) ALL
```
- Hier wäre die Stelle wo sich weitere Sachen installieren lassen, oder zumindest Updates machen…
  - Je nachdem was man haben möchte.
ssh Keys hinterlegen:
- mkdir ~user/.ssh
- Key in ~user/.ssh/authorized_keys hinterlegen.
  - Auf dem Web-Host hinterlegen und dann mit fetch.
  - Das Clipboard funktioniert zufällig?
  - Irgendwas mit scp…
  - Morse-Telegraphie…
- chown -R user:user ~user/.ssh
- chmod 700 ~user/.ssh

Wichtig! Bootloader installieren:

gpart bootcode -b /boot/pmbr -p /boot/gptzfsboot -i 1 da0
gpart bootcode -b /boot/pmbr -p /boot/gptzfsboot -i 1 da1

Fertig: exit!

Anmerkung der Redaktion: Beim letztendlichen installieren des Servers war der Order /var/home/user leer, was den Login mit ssh Keys bisschen schwierig macht. Also hier letzte Chance zu checken.

Pools exportieren

ZFS-Cache-File rüber kopieren:

cp /boot/zfs/zpool.cache /mnt/boot/zfs/zpool.cache

Die chroot Filesysteme aushängen und die Pools exportieren:
- umount /mnt/dev
- umount /mnt/tmp
- zpool export data
- zpool export virt
- zpool export core
- mount sollte wieder so gut wie leer sein…

Fertig

Jetzt aber wirklich Feierabend!

Das mfsbsd mit einem shutdown -p now sauber runterfahren. qemu beendet sich.

Dem Rescue-System noch einen guten Tag wünschen, und reboot.

Danach Einrichten.

last update: 2025-01-29 20:22:06 +0100