NixOS

NixOS est une distribution linux créé par Eelco Dolstra. C'est une distribution basée sur une philosophie immuable. NixOS n'est pas seulement une distribution, mais un projet entier. Le projet Nix constitue Nix qui est un langage de programmation, un gestionnaire de paquets avec Nixpkgs et aussi un os avec NixOS. D'autre partie du projet tel que nix cache ou nix hydra, ou encore nix infra sont des propriétés du Projet nix. Cette section dans la documentation est indispensable pour comprendre le reste des applicatifs et des déploiements dans cette documentation.

Nixpkgs

Nixpkgs est le gestionnaire de paquets de NixOS. Il est géré par la communauté nix. Il regroupe plus de 100 000 paquets. C'est actuellement le plus gros gestionnaire de paquets au monde. Possédant les paquets les plus à jours et les plus nombreux, on pourrait le comparer à AUR ou à portage. Cependant, il est plus proche de portage que d'AUR car il est basé sur un système de compilation et de dépendance. Si on le compare à AUR, nixpkgs possède quelque chose en plus : les modules NixOS. Il s'agit de la partie configuration de NixOS.

Pour avoir une aussi grande réactivité et autant de paquet disponible, nixpkgs utilise un système de pull request et de merge request. Il est donc possible de faire une pull request sur nixpkgs et d'ajouter n'importe quel paquet à NixOS. Bien évidement des responsables de la communauté, vérifient la pull request et la valident ou non. Si les paquets sont installé correctement et qu'il n'y a pas de problème de sécurité, si toutes ses conditions sont réunies, il est ajouté à nixpkgs.

Ensuite, il existe plusieurs branches de nixpkgs. master est la branche de développement, unstable est la branche de test et stable "NixOS-24.11" est la branche stable. La branche stable est la branche qui est utilisée par défaut par NixOS. Elle est mise à jour tous les six mois. C'est pour cela que les mises à jour majeures de NixOS sont tous les six mois. Cela permet de rajouter de nouveaux modules, et de faire les mises à jour majeures des paquets. Hors mise à jour majeure, nixpkgs est mis à jour très régulièrement pour les mises à jour de sécurité des paquets.

Modules

Qu'est-ce qu'un module NixOS ?

Les modules NixOS sont la partie configuration de NixOS. Ils vont se manifester sous la forme de composants combinables. Un module ne peut contenir que des expressions Nix et des options. Les modules nix sont utilisables sous Darwin et Linux, mais certains modules ne sont pas conçus pour fonctionner sous Darwin. La majorité du temps les modules qui sont utilisé dans Nix proviennent de nixpkgs mais il est aussi possible de créer ses propres modules et de les héberger dans une source.

Comment ça fonctionne ?

Les modules NixOS sont des fichiers Nix qui contiennent des options et des expressions Nix. Ils sont utilisés pour configurer NixOS et Nixpkgs. Les modules sont souvent utilisés pour configurer des services, des paquets ou des options de NixOS. C'est grâce à cela que NixOS peut être configuré de manière immuable. Les modules peuvent être aussi utilisé par les développeurs pour créer des paquets ou des services.

Build

Qu'est-ce que c'est le build dans NixOS ?

Comment fonctionne le build dans NixOS ? Le build dans NixOS est un processus qui permet de compiler les paquets et les modules de NixOS. Il ne permet pas seulement de compiler les paquets et les modules de NixOS, mais aussi de construire tout ce qui est définissable par nix. Une fois le résultat de la compilation obtenu, il est mis dans le cache de nixpkgs ou dans le cache de NixOS. Cela créera un hash qui est le résultat de la compilation.

Exemple de build sous NixOS

Ici, nous allons faire un exemple de build sous NixOS d'une application très basique en C.

Voici notre app départ :

#include <stdio.h>
int main() {
    printf("Hello World\n");
    return 0;
}

Et voici notre flake.nix qui va nous permettre de construire cet app

{
  # Description du flake
  description = "Hello World";

  # Importation de nixpkgs depuis GitHub (canal nixos-unstable)
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

  # Définition des sorties du flake
  outputs = { self, nixpkgs }:

    # Définition d'une liste de plateformes supportées
    let
      supportedSystems =
       [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" ];

      # Fonction  pour générer des sorties pour chaque systèmes
     forAllSystems = f: nixpkgs.lib.genAttrs supportedSystems (system:
        let
          # Importation de nixpkgs pour une architecture donnée
          pkgs = import nixpkgs { inherit system; };
        in
          # Application de la fonction f avec pkgs comme argument
          f pkgs
      );
    in

    {
      # Définition des paquets du flake
      packages = forAllSystems (pkgs: {
        # Paquet helloWorld pour chaque système
        helloWorld = pkgs.stdenv.mkDerivation {
          # Nom du paquet
          name = "hello-world";

          # Pas de source (on génère hello-world.c à la volée)
          src = ./.;

          # Dépendance pour la compilation : gcc
          buildInputs = [ pkgs.gcc ];
          

          # Phase de build : on compile hello-world.c avec gcc
          buildPhase = ''
            gcc -o hello-world hello-world.c
          '';

          # On installe le binaire dans $out/bin
          # Tous ce qui est dans $out est un result nix
          installPhase = ''
            mkdir -p $out/bin
            cp hello-world $out/bin/
          '';
        };
      });

      # Paquet par défaut à construire avec `nix build`
      defaultPackage = forAllSystems 
      (pkgs: self.packages.${pkgs.system}.helloWorld);
    };
}

Je build mon paquet avec la commande suivante :

nix build

Et nous pouvons retrouver notre binaire dans le dossier result :

Si j'exécute mon binaire, j'ai bien le résultat attendu :

Cependant si l'on regarde le chemin de mon dossier result, on peut voir qu'il se trouve dans le nix store.

On peut voir qu'il a pour hash le hash suivant :

jyksdr97i7i8s3nbnjkhfimxmmv2kjr3

Si maintenant, je modifie mon code source et que je le recompile, je vais avoir un nouveau hash.

Cache

Qu'est-ce que c'est le cache dans Nixos ? Dans Nixos le cache est un endroit où sont stockés les résultats de build nixos. Tout ce qui est buildable dans Nixos peut être mis dans le cache.

Le cache de nixpkgs

Comment fonctionne le cache de nixpkgs ? Le cache de nixpkgs est un endroit où sont stockés les résultats de build de nixpkgs. Donc tous les paquets et tous les modules ajoutés par la communauté de nixpkgs sont stockés dans le cache de nixpkgs. Mais pour avoir les résultats des builds de nixpkgs, il faut les builder. Cela est fait grâce à Nix Hydra. Nix Hydra est une infrastructure et la platforme principale de build de nixpkgs et de Nixos. Par défaut tout ce qui est construit par Nix Hydra est trust. Ensuite une fois que Nix Hydra a construit un paquet, il est introduit dans le cache de nixpkgs et grâce à ce pipeline, on est sûr que tout ce qui est dans le cache de nixpkgs est trust et buildable.

Pourquoi utiliser un cache personnel

Il est intéressant d'utiliser un cache personnel pour plusieurs raisons. La premiere raison est lorsque plusieurs développeurs travaillent sur un projet compilé. Si le paquet sur lequel, ils travaillent est situé sur un cache en commun, ils peuvent l'utiliser pour ne pas avoir à le builder à chaque fois et ne builder que les différences entre les versions du paquet. Ensuite pour les administrateurs systèmes qui gèrent des parcs de machines Nixos, cela leur permet de savoir exactement ce qui est installé sur leurs machines et d'avoir la certitude d'être capable de reconstruire une machine à l'identique à l'aide du cache.

Tests Nixos

Les tests Nixos sont une feature qui est introduite grâce à la feature des flake qui intègre les nix checks. Cette feature est encore expérimentale, mais énormément utilisée par la communauté depuis plus d'une dizaine d'années. Les tests Nixos sont des tests qui permettent de tester les paquets et les modules Nixos. Ils permettent aussi de tester les différents environnements de Nixos et de s'assurer que tout fonctionne correctement. Les tests Nixos sont aussi utilisé pour tester les configurations des machines Nixos, ce qui nous permet de pouvoir tester nos configurations avant de les déployer sur nos machines. Cela est très pratique pour faire du déployment continu et de l'intégration continue.

Colmena

Colmena est un projet NixOS permettant de gérer des flottes de machines NixOS à distance. Cet outil permet de pouvoir builder parallèlement des configurations nixos. Cet outil permet aussi d'appliquer des configurations nixos sur des machines à distance. Via une option de nixos qui est le rebuild distant.

Comment fonctionne le rebuild distant ?

Le rebuild distant est une option de Nixos qui permet de builder une configuration nixos sur une machine distante. Il fonctionne de la même manière que le rebuild local. Sauf que cette fois-ci notre machine de développement va d'abord builder la configuration nixos sur la machine distante. Une fois que la configuration est buildée, elle va l'appliquer sur la machine distante en utilisant le daemon Nixos de la machine distante. Cette méthode permet notamment de faire des mises à jour offline de la machine distante.

Last modified: 11 April 2025