nix/README.md

NixOS-konfiguration

Det här förrådet innehåller en flake-baserad NixOS-konfiguration för mina maskiner.

Just nu finns hosten kronos, med:

• Hyprland
• ZFS som root-filsystem
• LUKS under ZFS
• TPM2 för automatisk upplåsning av LUKS
• zram i stället för swap-partition
• systemd-networkd och systemd-resolved
• GRUB med os-prober för Windows-stöd
• NVIDIA med nvidia-open för kronos
• OpenSSH
• automatiska ZFS-snapshots

Dotfiles hanteras inte av Nix i det här förrådet. De installeras separat med stow från ~/dotfiles.

Struktur

• flake.nix är startpunkten
• hosts/kronos/default.nix är huvudfilen för maskinen kronos
• hosts/kronos/disko.nix beskriver disk-layouten
• hosts/kronos/hardware-configuration.nix är hårdvaruspecifik och genereras på maskinen
• modules/base.nix innehåller grundsystem
• modules/zfs-root.nix innehåller boot, LUKS, TPM och ZFS-relaterade delar
• modules/desktop-hyprland.nix innehåller desktopmiljön och paketen

Viktigt innan installation

Det finns några saker som måste ändras innan konfigurationen används på en ny maskin.

1. Kontrollera att rätt disk är vald i hosts/kronos/default.nix
   • just nu pekar installDisk på /dev/disk/by-id/wwn-0x5001b444a9734c0e
   • det är tänkt att vara nuvarande Arch-disken på kronos
   • ändra detta innan återanvändning på annan maskin
2. Generera riktig hardware-configuration.nix
   • den nuvarande filen är bara en platshållare tills den genereras på målsystemet
3. Kontrollera networking.hostId
   • ZFS kräver att den är satt
4. Tänk på att disken raderas
   • disko partitionerar, formaterar och skapar LUKS/ZFS enligt konfigurationen
5. kronos antar NVIDIA
   • hosten är nu konfigurerad för nvidia-open med modesetting

Disk-layouten är just nu:

• EFI för boot
• LUKS på resten av disken
• ZFS pool (rpool) ovanpå den upplåsta LUKS-enheten
• ingen vanlig swap-partition på disk
• zram används för swap i RAM

Bootloadern är GRUB, inte systemd-boot, eftersom kronos är satt upp för att hitta andra installerade system via os-prober, till exempel Windows.

Installation från minimal NixOS-installationsmedia

Om nätverket inte redan fungerar i installationsmediet:

nmtui

Sedan:

sudo -i
export NIX_CONFIG='experimental-features = nix-command flakes'
cd /tmp
git clone <repo-url> nixcfg
cd nixcfg

Redigera sedan rätt disk i hosts/kronos/default.nix:

vim hosts/kronos/default.nix

Applicera disk-layouten:

nix run github:nix-community/disko -- --mode disko .#kronos

Det kommandot gör i praktiken detta:

• partitionerar disken
• skapar EFI-partitionen
• skapar LUKS-enheten cryptroot
• skapar ZFS-poolen rpool
• skapar datasets
• monterar målsystemet under /mnt

Det är därför nästa steg använder /mnt.

Generera hårdvarufilen och kopiera in den i förrådet:

nixos-generate-config --root /mnt
cp /mnt/etc/nixos/hardware-configuration.nix ./hosts/kronos/hardware-configuration.nix

Installera systemet:

nixos-install --flake .#kronos

Enrolla sedan TPM-nyckeln innan omstart:

nixos-enter --root /mnt -c 'systemd-cryptenroll --tpm2-device=auto --tpm2-pcrs=7 /dev/disk/by-partlabel/cryptroot'

Och starta om:

reboot

Vad TPM-upplåsningen betyder

TPM ersätter inte ditt vanliga LUKS-lösenord. Den lägger till en extra väg för upplåsning.

Det betyder:

• LUKS kan fortfarande låsas upp med recovery-lösenord/passphrase
• maskinen kan låsa upp automatiskt med TPM om boot-tillståndet matchar
• om firmware, Secure Boot eller PCR-värden ändras kan du behöva skriva lösenordet manuellt en gång och sedan enrolla om TPM

Efter första uppstart

Kloning av dotfiles och installation med stow görs separat:

git clone <dotfiles-repo> ~/dotfiles
cd ~/dotfiles
stow ghostty foot hyprland paru shell tmux wezterm

Observera att dina nuvarande Hyprland-dotfiles fortfarande försöker starta nm-applet. Eftersom systemet använder systemd-networkd i stället för NetworkManager bör den raden tas bort eller ersättas efter att dotfiles har stow:ats in.

Vanligt underhåll

När systemet väl är installerat jobbar man oftast så här.

Uppdatera flake-låset:

nix flake update

Bygg och applicera ändringar på den lokala maskinen:

sudo nixos-rebuild switch --flake .#kronos

Testa en konfiguration utan att göra den permanent vid nästa boot:

sudo nixos-rebuild test --flake .#kronos

Bygg bara, utan att byta system direkt:

sudo nixos-rebuild build --flake .#kronos

Rensa gamla generationer och oanvända paket:

sudo nix-collect-garbage -d

Kontrollera ZFS-snapshots:

zfs list -t snapshot

Kontrollera OpenSSH:

systemctl status sshd

Bra arbetssätt är ofta:

• ändra Nix-filerna
• kör nixos-rebuild test eller switch
• verifiera att allt fungerar
• committa ändringen i förrådet

Eftersom NixOS sparar generationer är det också lättare att backa tillbaka än i många traditionella distributioner.

Flera maskiner i samma förråd

Det här upplägget är gjort för att flera maskiner ska kunna leva i samma förråd.

En vanlig struktur är:

• gemensamma moduler i modules/
• en mapp per maskin i hosts/<namn>/

För att lägga till en ny maskin kan du till exempel:

1. skapa en ny mapp, till exempel hosts/atlas/
2. lägga in en egen default.nix
3. lägga in en egen disko.nix om disk-layouten skiljer sig
4. generera en egen hardware-configuration.nix på den maskinen
5. lägga till hosten i flake.nix

Exempel i flake.nix:

nixosConfigurations = {
  kronos = nixpkgs.lib.nixosSystem {
    system = "x86_64-linux";
    specialArgs = { inherit inputs; };
    modules = [
      disko.nixosModules.disko
      ./hosts/kronos
    ];
  };

  atlas = nixpkgs.lib.nixosSystem {
    system = "x86_64-linux";
    specialArgs = { inherit inputs; };
    modules = [
      disko.nixosModules.disko
      ./hosts/atlas
    ];
  };
};

Sedan kan varje maskin byggas separat:

sudo nixos-rebuild switch --flake .#kronos
sudo nixos-rebuild switch --flake .#atlas

Det fina med detta är att gemensamma delar, som base.nix eller desktop-hyprland.nix, kan återanvändas, medan varje maskin ändå kan ha egen:

• disk-layout
• hostname
• hårdvarufil
• användare eller roller
• specialpaket eller tjänster

Sammanfattning

Tanken med förrådet är:

• ett ställe för systemkonfiguration
• separata hostar per maskin
• återanvändbara moduler för gemensamma delar
• dotfiles separat via stow
• enkel reproducerbar installation från minimal NixOS-media

Observera att NVIDIA-delen just nu är hostspecifik för kronos. Om du lägger till en annan maskin utan NVIDIA bör du inte kopiera den delen rakt av.

Begrepp som kan vara bra att känna till

sops-nix och agenix är två vanliga sätt att hantera hemligheter i NixOS, utan att lägga lösenord, tokens eller nycklar i klartext i förrådet.

• sops-nix bygger på Mozilla sops

• hemligheter krypteras i filer som kan committas till git

• dekryptering sker på rätt maskin vid aktivering, typiskt med age eller GPG

• bra när man vill ha ett centralt, versionshanterat sätt att hantera secrets

• agenix bygger i stället direkt på age

• det är ofta enklare och mer minimalt än sops-nix

• vanligt val om man bara vill ha några hemligheter och ett lättare upplägg

Typiska användningsfall är:

• Wi-Fi-hemligheter
• API-nycklar
• tokens
• privata SSH-nycklar för tjänster
• lösenord till systemtjänster

impermanence är ett upplägg där stora delar av systemet behandlas som förbrukningsbara mellan boots.

Det brukar betyda att:

• root-filsystemet återställs till ett rent grundläge vid boot
• bara vissa kataloger sparas permanent, till exempel /home, /var/lib eller annat under /persist
• systemet blir lättare att hålla rent och reproducibelt

Det passar extra bra ihop med ZFS, eftersom snapshots och rollback redan finns naturligt där.

Fördelar med impermanence:

• mindre konfigurationsdrift över tid
• lättare att veta vad som faktiskt är deklarativt
• enklare återställning efter experiment eller fel

Nackdelen är att det kräver att man tänker igenom vad som faktiskt ska sparas. Det är ofta något man lägger till senare, när grundinstallationen redan känns stabil.