Práctica 39: NixOS — el sistema operativo declarativo

• Entender la diferencia entre configuración imperativa (Ubuntu, Windows) y declarativa (NixOS, Terraform, Kubernetes).
• Conocer las tres ideas centrales de Nix: store inmutable, derivación reproducible, generaciones con rollback atómico.
• Instalar NixOS desde la ISO minimal usando particionado manual y nixos-install.
• Leer y editar /etc/nixos/configuration.nix para añadir paquetes, usuarios y servicios.
• Aplicar cambios con nixos-rebuild switch y observar cómo el sistema entero se construye otra vez.
• Romper la configuración a propósito y volver atrás con nixos-rebuild switch --rollback o desde GRUB.
• Usar nix-shell para crear entornos efímeros con herramientas que no quieres instalar de forma permanente.
• Comparar con Ubuntu: qué te cuesta más, qué te cuesta menos, qué problemas desaparecen.
• Diagnosticar tres fallos típicos: error de sintaxis en configuration.nix, paquete que no existe, sin red durante el rebuild.
• Documentar tu configuración final y entregarla como parte de la ficha técnica.

0.1 — El problema que NixOS quiere resolver

Imagina la siguiente escena, que pasa todos los días en oficinas de todo el mundo:

• El servidor de producción lleva tres años funcionando.
• Nadie recuerda exactamente qué cambios se le han hecho.
• Hay que "replicarlo" en otro servidor.
• Resultado: tres semanas de prueba/error, y el nuevo servidor casi es igual al viejo. Casi.

Este problema se llama configuration drift: el estado real del sistema se va alejando con el tiempo de cualquier documentación que tuvieras. Lo causan tres prácticas:

1. Hacer cambios con apt install sin apuntarlo.
2. Editar archivos a mano sin control de versiones.
3. Aplicar parches manuales que el siguiente apt upgrade sobrescribe.

Las soluciones parcheadas al problema son Ansible, Puppet, Chef, Docker… Todas son capas encima de un SO imperativo. NixOS le da la vuelta: el SO entero es el resultado de un archivo declarativo. Si dos máquinas tienen el mismo configuration.nix y la misma versión de Nix, son bit a bit idénticas.

0.2 — Las tres ideas de Nix

1. Store inmutable

Todos los paquetes se instalan en /nix/store/ bajo una ruta que incluye un hash criptográfico. Por ejemplo:

/nix/store/abc123...-firefox-115.0.2/
/nix/store/def456...-firefox-116.0.0/

Los dos Firefox conviven sin pisarse. Nadie sobrescribe nada nunca. Para "actualizar" lo que se hace es cambiar a qué hash apunta el enlace /run/current-system.

2. Derivación reproducible

El hash de cada paquete se calcula a partir de todas sus entradas: fuente, compilador, flags, dependencias, sistema operativo. Si tú y otra persona compiláis el mismo paquete con los mismos parámetros, sale exactamente el mismo hash y los mismos bytes. Esto se llama build reproducible.

3. Generaciones con rollback

Cada vez que aplicas un cambio (nixos-rebuild switch) NixOS crea una nueva generación del sistema. La generación anterior sigue en disco. Si la nueva no arranca o tiene un fallo, eliges la anterior en el GRUB y estás otra vez en el estado de antes. El rollback es atómico: o estás en la generación nueva entera, o en la vieja entera, no en mitad de un upgrade roto.

0.3 — Imperativo vs declarativo, con un ejemplo

apt install nginx
systemctl enable nginx
sed -i 's/.../.../g' /etc/nginx/nginx.conf
systemctl restart nginx
ufw allow 80

services.nginx.enable = true;
services.nginx.virtualHosts."example" = {
  root = "/var/www";
};
networking.firewall.allowedTCPPorts = [ 80 ];

0.4 — Vocabulario mínimo del mundo Nix

1.1 — Descargar la ISO

Desde https://nixos.org/download, sección "NixOS: the Linux distribution" → ISO image → Minimal ISO image (64-bit Intel/AMD). Aproximadamente 1 GB.

1.2 — Crear la VM

2.1 — Arrancar y entrar como root

Arranca la VM. Tras el menú, aparece un prompt como [nixos@nixos:~]$. Estás en un Live ISO. Pasa a root:

sudo -i

2.2 — Particionar (UEFI + GPT)

parted /dev/sda -- mklabel gpt
parted /dev/sda -- mkpart ESP fat32 1MB 512MB
parted /dev/sda -- set 1 esp on
parted /dev/sda -- mkpart primary 512MB 100%

Resultado: /dev/sda1 (EFI) y /dev/sda2 (root).

2.3 — Formatear y montar

mkfs.fat -F32 -n boot /dev/sda1
mkfs.ext4 -L nixos /dev/sda2

mount /dev/disk/by-label/nixos /mnt
mkdir -p /mnt/boot
mount /dev/disk/by-label/boot /mnt/boot

2.4 — Generar la configuración inicial

nixos-generate-config --root /mnt
ls /mnt/etc/nixos/
# verás: configuration.nix  hardware-configuration.nix

Nix ha detectado tu hardware y ha escrito un esqueleto. Vamos a tocarlo:

nano /mnt/etc/nixos/configuration.nix

2.5 — Editar configuration.nix mínimo

Descomenta o añade estas líneas (déjalas similares a esto, dentro del bloque grande):

{
  imports = [ ./hardware-configuration.nix ];

  boot.loader.systemd-boot.enable = true;
  boot.loader.efi.canTouchEfiVariables = true;

  networking.hostName = "nixos-lab";
  networking.networkmanager.enable = true;

  time.timeZone = "Europe/Madrid";
  i18n.defaultLocale = "es_ES.UTF-8";
  console.keyMap = "es";

  users.users.alumno = {
    isNormalUser = true;
    extraGroups = [ "wheel" "networkmanager" ];
    initialPassword = "alumno123";
  };

  environment.systemPackages = with pkgs; [
    vim
    git
    htop
  ];

  services.openssh.enable = true;

  # Pon aquí la versión que apuntaste al descargar la ISO.
  # Ejemplo: "25.11", "26.05"... Mírala con `nixos-version` antes de instalar.
  system.stateVersion = "25.11";
}

2.6 — Instalar

nixos-install
# pedirá contraseña de root para el sistema instalado
reboot

(Antes de que arranque el sistema, retira la ISO del slot del DVD en VirtualBox.)

Login con el usuario alumno y la contraseña alumno123. Ejecuta:

cat /etc/os-release
nixos-version
ls -l /run/current-system
# es un symlink a /nix/store/HASH-nixos-system-...

readlink /run/current-system
nix-store -q --references /run/current-system | head
ls /nix/store | wc -l

El último número probablemente sea ya 5.000+ entradas. Cada una es un paquete o una "derivación" en el store inmutable.

3.1 — Generaciones

sudo nix-env --list-generations -p /nix/var/nix/profiles/system

Solo deberías ver una, la 1. Vamos a hacer que aparezca la 2.

4.1 — Añadir paquetes

Edita /etc/nixos/configuration.nix y en environment.systemPackages añade tree, tmux y firefox:

environment.systemPackages = with pkgs; [
  vim
  git
  htop
  tree
  tmux
  firefox
];

Aplica:

sudo nixos-rebuild switch

Esto descarga paquetes, los une en una nueva generación y la activa. Comprueba:

which tree
sudo nix-env --list-generations -p /nix/var/nix/profiles/system
# ahora hay 2 generaciones

4.2 — Habilitar un servicio

Añade Nginx con una página de prueba. En configuration.nix:

services.nginx = {
  enable = true;
  virtualHosts."hello" = {
    default = true;
    root = "/var/www";
  };
};

networking.firewall.allowedTCPPorts = [ 80 ];

system.activationScripts.miweb = ''
  mkdir -p /var/www
  echo "<h1>Hola desde NixOS</h1>" > /var/www/index.html
'';

Reaplica:

sudo nixos-rebuild switch
curl http://localhost/
# debe responder "Hola desde NixOS"

4.3 — Romper algo a propósito

Edita configuration.nix y cambia services.nginx.enable = true; por services.nginx.enable = "si"; (mal tipo).

sudo nixos-rebuild switch

Nix se queja con un error de tipo y no aplica nada. Tu sistema sigue funcionando con la generación anterior intacta. Esto es lo que distingue a un sistema declarativo: errores en la config no rompen el sistema en marcha.

4.4 — Rollback de verdad

Deja Nginx bien otra vez. Aplica. Ahora simula un cambio "malo": quita Nginx, aplica, y luego decide que querías volver atrás:

sudo nixos-rebuild switch --rollback
# vuelves a la generación anterior con un comando

Comprueba con nix-env --list-generations y con un curl localhost/: Nginx vuelve a estar.

Una cosa muy potente de Nix es lanzar una shell con paquetes sin instalarlos en el sistema:

nix-shell -p cowsay
cowsay "Hola"
exit
# fuera de la shell, cowsay no existe

Útil para probar herramientas. Y se puede combinar:

nix-shell -p nodejs python3 sqlite
# tienes los tres juntos en una sub-shell

Cuando sales, no queda nada instalado. Cuando vuelves a entrar, sale de la caché.

5.1 — Reproducible: un shell.nix

Crea un archivo shell.nix en tu home:

{ pkgs ? import <nixpkgs> {} }:
pkgs.mkShell {
  buildInputs = [ pkgs.nodejs pkgs.python3 ];
}

Y desde el mismo directorio:

nix-shell

Cualquiera que clone esa carpeta y tenga Nix tendrá exactamente los mismos node y python. Esto es lo que en Python se intenta con venv, en JS con nvm… aquí es nativo.