NixOS: Der umfassende Leitfaden vom Paketmanager Nix für Anfänger

Nix ist ein einzigartiger, rein funktionaler Paketmanager, der sich durch reproduzierbare, deklarative und zuverlässige Paketverwaltung auszeichnet. Anders als traditionelle Paketmanager verwendet Nix ein einzigartiges Konzept der unveränderlichen Pakete und isolierten Umgebungen.

Grundlegende Konzepte

Der Nix Store

Alle Pakete werden im Nix Store unter /nix/store gespeichert.

Jedes Paket erhält einen eindeutigen Hash-basierten Pfad:

/nix/store/2727m90vgx8bbirkaqvry3h4n3mlqr4n-firefox-119.0/

Was bedeutet der Pfad?

• 2727m90v...: Hash aller Build-Inputs
• firefox: Paketname
• 119.0: Version

Nix-Profile

Profile sind Benutzerumgebungen, die Pakete zusammenfassen.

Aktuelles Profil anzeigen

nix profile list

Beispielausgabe

0 firefox-119.0   2024-01-20 /nix/store/2727m90v...
1 vim-9.0.1503    2024-01-20 /nix/store/6qz9m1v...

Die configuration.nix (NixOS)

{ config, pkgs, ... }:
{
  environment.systemPackages = with pkgs; [
    firefox
    vim
    git
  ];
}

Pakete installieren

Grundlegende Installation

Mit nix-env (traditionell)

nix-env -iA nixpkgs.firefox

Beispielausgabe:

resolving 'firefox' from nixpkgs...
building '/nix/store/2727m90vgx8bbirkaqvry3h4n3mlqr4n-user-environment.drv'...
installing 'firefox-119.0'
building path(s) '/nix/store/2727m90vgx8bbirkaqvry3h4n3mlqr4n-firefox-119.0'

Mit nix profile (modern)

nix profile install nixpkgs#firefox

⚠️ WICHTIGE HINWEISE:

• Nix erstellt für jede Installation einen eigenen Store-Pfad
• Mehrere Versionen können parallel existieren
• Rollbacks sind jederzeit möglich

Erweiterte Optionen

Spezifische Version installieren

nix-env -iA nixpkgs.firefox-102-esr

Aus einem bestimmten Channel

nix-env -iA nixos-23.11.firefox

Flakes verwenden (modern)

nix profile install github:NixOS/nixpkgs#firefox

Paketmanagement

Profile verwalten

Profile auflisten

nix profile list

Beispielausgabe:

Index:    0
Name:     firefox
Version:  119.0
Path:     /nix/store/2727m90v..-firefox-119.0

Generationen verwalten

Generationen anzeigen:

nix-env --list-generations

Zu einer Generation wechseln

nix-env --switch-generation 42

Alte Generationen löschen

nix-env --delete-generations old

Pakete aktualisieren

Einzelnes Paket aktualisieren

nix-env -u firefox

Alle Pakete aktualisieren

nix-env -u

⚠️ WARNUNG:

• Prüfe immer die Änderungen vor dem Update
• Beachte mögliche Breaking Changes

Pakete entfernen

Mit nix-env

nix-env -e firefox

Mit nix profile

nix profile remove nixpkgs#firefox

Deklarative Paketverwaltung

In configuration.nix

{ config, pkgs, ... }:
{
  environment.systemPackages = with pkgs; [
    firefox
    (vim_configurable.override {
      python3Support = true;
    })
    git
  ];
}

Änderungen anwenden:

sudo nixos-rebuild switch

Flakes verwenden

{
  description = "My System Configuration";
  
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-23.11";
  };
  
  outputs = { self, nixpkgs }: {
    nixosConfigurations.mysystem = nixpkgs.lib.nixosSystem {
      system = "x86_64-linux";
      modules = [ ./configuration.nix ];
    };
  };
}

Die Nix-Sprache

Grundlegende Syntax

Einfache Ausdrücke

# Attribute Set
{
  name = "firefox";
  version = "119.0";
  buildInputs = [ gtk3 dbus ];
}

# Listen
[ firefox vim git ]

# Funktionen
pkg: pkg.override { enableGUI = true; }

Derivations erstellen

Einfache Derivation

derivation {
  name = "hello-2.12";
  builder = "${bash}/bin/bash";
  args = [ ./builder.sh ];
  system = "x86_64-linux";
  src = fetchurl {
    url = "mirror://gnu/hello/hello-2.12.tar.gz";
    sha256 = "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i";
  };
}

⚠️ WICHTIG:

• Derivations sind die Bauanleitungen für Pakete
• Alle Abhängigkeiten müssen explizit angegeben werden
• Builds sind reproduzierbar

Fortgeschrittene Paketierung

Overlays verwenden

Overlay definieren

~/.config/nixpkgs/overlays/custom.nix

self: super: {
  firefox = super.firefox.override {
    enableTridactylNative = true;
  };
}

System-weites Overlay

configuration.nix

{
  nixpkgs.overlays = [
    (import ./overlays/custom.nix)
  ];
}

Eigene Pakete erstellen

Default.nix

{ stdenv, lib, fetchFromGitHub }:

stdenv.mkDerivation rec {
  pname = "mein-programm";
  version = "1.0.0";

  src = fetchFromGitHub {
    owner = "username";
    repo = "mein-programm";
    rev = "v${version}";
    sha256 = "...";
  };

  buildInputs = [ ];

  meta = with lib; {
    description = "Mein eigenes Programm";
    homepage = "https://github.com/username/mein-programm";
    license = licenses.mit;
    platforms = platforms.linux;
  };
}

Entwicklungsumgebungen

nix-shell

Shell.nix erstellen

{ pkgs ? import <nixpkgs> {} }:

pkgs.mkShell {
  buildInputs = with pkgs; [
    python3
    poetry
    nodejs
    yarn
  ];

  shellHook = ''
    export PYTHONPATH="${pkgs.python3}/bin/python"
  '';
}

Entwicklungsumgebung starten

nix-shell

Oder mit Flakes

nix develop

direnv Integration

.envrc erstellen

use nix

direnv aktivieren

direnv allow

Garbage Collection

Nix Store bereinigen

Manuelle Bereinigung

Nicht mehr benötigte Pakete entfernen:

nix-collect-garbage

Alte Generationen löschen:

nix-collect-garbage -d

Automatische Bereinigung

configuration.nix

{
  nix.gc = {
    automatic = true;
    dates = "weekly";
    options = "--delete-older-than 30d";
  };
}

⚠️ WARNUNG:

• Sichere wichtige Generationen vor der Bereinigung
• Prüfe aktive Prozesse
• Beachte Rollback-Möglichkeiten

Best Practices

System-Konfiguration

Modulare Konfiguration

/etc/nixos/configuration.nix

{
  imports = [
    ./hardware-configuration.nix
    ./desktop.nix
    ./development.nix
    ./services.nix
  ];
}

Flakes-Struktur

.
├── flake.nix
├── flake.lock
└── modules/
    ├── desktop/
    │   ├── default.nix
    │   ├── kde.nix
    │   └── gnome.nix
    ├── development/
    └── services/

Reproduzierbarkeit sicherstellen

Versionen fixieren

{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-23.11";
    home-manager = {
      url = "github:nix-community/home-manager/release-23.11";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };
}

Troubleshooting

Häufige Probleme und Lösungen

Konfliktlösung

Build-Fehler analysieren:

nix-build --show-trace

Abhängigkeiten prüfen:

nix-store -q --references /nix/store/<hash>-package

Store-Reparatur

Store-Konsistenz prüfen:

nix-store --verify

Beschädigte Pfade reparieren:

nix-store --repair-path /nix/store/<hash>-package

Debug-Techniken

Debug-Shell

stdenv.mkDerivation {
  # ...
  shellHook = ''
    export NIX_DEBUG=1
    export NIX_LOG_PATH=/tmp/nix-build.log
  '';
}

Build-Logs analysieren

nix log /nix/store/<hash>

Detaillierte Build-Ausgabe:

nix-build -K . |& tee build.log

Fortgeschrittene Anwendungsfälle

Container und VMs

NixOS-Container

configuration.nix

{
  containers.myapp = {
    config = { config, pkgs, ... }: {
      system.stateVersion = "23.11";
      services.nginx.enable = true;
    };
  };
}

VM-Images erstellen

nix-build '<nixpkgs/nixos>' -A config.system.build.virtualBoxImage

CI/CD-Integration

GitHub Actions

name: "Build"
on:
  pull_request:
  push:
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: cachix/install-nix-action@v22
    - run: nix build .#

Performance-Optimierung

Binary Cache einrichten

{
  nix = {
    settings = {
      substituters = [
        "https://cache.nixos.org"
        "https://mycache.org"
      ];
      trusted-public-keys = [
        "cache.nixos.org-1:..."
        "mycache.org-1:..."
      ];
    };
  };
}

Build-Parallelisierung

{
  nix.settings = {
    max-jobs = "auto";
    cores = 0;
    sandbox = true;
  };
}

Sicherheit und Wartung

Regelmäßige Wartungsaufgaben

Update-Routine

System aktualisieren:

sudo nixos-rebuild switch --upgrade

Store bereinigen:

sudo nix-collect-garbage -d

Bootloader-Einträge aufräumen:

sudo /run/current-system/bin/switch-to-configuration boot

Sicherheits-Checks

Verwaiste Pakete finden:

nix-store --gc --print-dead

Nicht referenzierte Pfade finden:

nix-store --verify --check-contents

Expertentipps

Systemoptimierung

Speicherplatz sparen

{
  nix.settings.auto-optimise-store = true;
  nix.optimise.automatic = true;
}

Build-Cache optimieren

{
  nix.settings = {
    keep-outputs = true;
    keep-derivations = true;
  };
}

Debugging und Entwicklung

Nix-Repl nutzen

nix repl
nix-repl> :l <nixpkgs>
nix-repl> firefox.buildInputs

Store analysieren

Abhängigkeitsgraph erstellen:

nix-store -q --graph /nix/store/<hash> | dot -Tpng > graph.png

Abschließende Empfehlungen

1. Dokumentation pflegen
   • Konfigurationsänderungen dokumentieren
   • Build-Skripte kommentieren
   • Abhängigkeiten dokumentieren
2. Backup-Strategie
   • Regelmäßige Konfigurationsbackups
   • Wichtige Generationen sichern
   • Binary Caches spiegeln
3. Community-Ressourcen nutzen
   • NixOS Discourse Forum
   • GitHub Discussions
   • IRC/Matrix Channels

Wichtige Ressourcen

Offizielle Dokumentation

• Nix Manual: https://nixos.org/manual/nix/stable/
• NixOS Manual: https://nixos.org/manual/nixos/stable/
• Nixpkgs Manual: https://nixos.org/manual/nixpkgs/stable/
• Nix Reference: https://nixos.org/learn.html

Community-Ressourcen

• NixOS Discourse: https://discourse.nixos.org/
• NixOS Wiki: https://nixos.wiki/
• Nix Pills: https://nixos.org/guides/nix-pills/
• Nix Flakes Community Wiki: https://nixos.wiki/wiki/Flakes

Entwickler-Ressourcen

• Nixpkgs Repository: https://github.com/NixOS/nixpkgs
• Nix Package Search: https://search.nixos.org/packages
• Nix Options Search: https://search.nixos.org/options
• RFC Repository: https://github.com/NixOS/rfcs

Lernressourcen

• NixOS Learning Resources: https://nixos.org/learn.html
• Nix.dev: https://nix.dev/
• Zero to Nix: https://zero-to-nix.com/

Fazit

Nix und NixOS bieten einen einzigartigen, deklarativen Ansatz zur Paketverwaltung und Systemkonfiguration. Die Kombination aus unveränderlichen Paketen, reproduzierbaren Builds und atomaren Updates macht Nix zu einem besonders leistungsfähigen Werkzeug für Systemadministratoren und Entwickler. Die anfängliche Lernkurve mag steil sein, aber die Vorteile der reproduzierbaren und zuverlässigen Systemverwaltung überwiegen bei weitem.

⚠️ Wichtiger Hinweis:

Nix und NixOS entwickeln sich ständig weiter, insbesondere mit der Einführung von Flakes und neuen Experimentalfeatures. Überprüfe regelmäßig die offizielle Dokumentation auf Änderungen und neue Funktionen. Die hier beschriebenen Methoden können sich mit der Zeit ändern. Mit diesem umfassenden Wissen und den zur Verfügung stehenden Ressourcen bist du gut gerüstet, um dein System effektiv mit Nix zu verwalten.

Denk immer daran: Mit der wachsenden Adoption von Nix und der aktiven Community wird das Ökosystem ständig verbessert und erweitert.

Aktualisierungen und Änderungen

Dieser Artikel wird regelmäßig aktualisiert, um neue Entwicklungen und Best Practices zu berücksichtigen. Die letzte Aktualisierung erfolgte am 24. Oktober 2024.