# 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: ```bash nmtui ``` Sedan: ```bash sudo -i export NIX_CONFIG='experimental-features = nix-command flakes' cd /tmp git clone nixcfg cd nixcfg ``` Redigera sedan rätt disk i `hosts/kronos/default.nix`: ```bash vim hosts/kronos/default.nix ``` Applicera disk-layouten: ```bash 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: ```bash nixos-generate-config --root /mnt cp /mnt/etc/nixos/hardware-configuration.nix ./hosts/kronos/hardware-configuration.nix ``` Installera systemet: ```bash nixos-install --flake .#kronos ``` Enrolla sedan TPM-nyckeln innan omstart: ```bash nixos-enter --root /mnt -c 'systemd-cryptenroll --tpm2-device=auto --tpm2-pcrs=7 /dev/disk/by-partlabel/cryptroot' ``` Och starta om: ```bash 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: ```bash git clone ~/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: ```bash nix flake update ``` Bygg och applicera ändringar på den lokala maskinen: ```bash sudo nixos-rebuild switch --flake .#kronos ``` Testa en konfiguration utan att göra den permanent vid nästa boot: ```bash sudo nixos-rebuild test --flake .#kronos ``` Bygg bara, utan att byta system direkt: ```bash sudo nixos-rebuild build --flake .#kronos ``` Rensa gamla generationer och oanvända paket: ```bash sudo nix-collect-garbage -d ``` Kontrollera `ZFS`-snapshots: ```bash zfs list -t snapshot ``` Kontrollera `OpenSSH`: ```bash 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//` 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`: ```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: ```bash 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.