Flakes/fr: Difference between revisions

====Introduction====

Les flocons Nix appliquent une structure uniforme pour les projets Nix, épinglent les versions de leurs dépendances dans un fichier de verrouillage et facilitent l'écriture d'expressions Nix reproductibles.

* Un [https://nixos.org/manual/nix/unstable/command-ref/new-cli/nix3-flake.html#description flocon] fait référence à une arborescence de système de fichiers dont le répertoire racine contient la spécification de fichier Nix appelée

<code>flake.nix</code>.

* Le contenu d'un fichier <code>flake.nix</code> suit un schéma de dénomination uniforme pour déclarer les paquets et leurs dépendances dans le langage Nix

* Les flocons introduisent une [https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-flake.html#flake-references syntaxe de type URL] pour spécifier des sources distantes.

* Pour simplifier la syntaxe des URL longues avec des noms plus courts, [https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-registry.html les flocons utilisent des registres] d'identifiants symbolique.  

* Pour simplifier la syntaxe des URL longues avec des noms plus courts, [https://nixos.org/manual/nix/stable/command-ref/new-cli/nix3-registry.html flakes utilise un registre] d'identifiants symboliques.

* Les flocons permettent également de verrouiller des références et des versions, qui peuvent ensuite être interrogées et mises à jour de manière programmatique.

* An [https://nixos.org/manual/nix/stable/command-ref/new-cli/nix.html experimental command-line interface] accepts flake references for expressions that build, run, and deploy packages.

<span id="Enable_flakes_temporarily"></span>

<span id="Enable_flakes_permanently_in_NixOS"></span>

Add the following to the [[Overview_of_the_NixOS_Linux_distribution#Declarative_Configuration system configuration |NixOS configuration]]:

<span id="Other_Distros,_with_Home-Manager"></span>

<span id="Other_Distros,_without_Home-Manager"></span>

Add the following to <code>~/.config/nix/nix.conf</code> or <code>/etc/nix/nix.conf</code>:

<span id="Basic_Usage_of_Flake"></span>

===Utilisation de base des Flocons===

{{Warning | Since contents of flake files are copied to the world-readable Nix store folder, do not put any unencrypted secrets in flake files. You should instead use a [[Comparison of secret managing schemes|secret managing scheme]].}}

<span id="Git_WARNING"></span>

====AVERTISSEMENT Git====

Therefore, if you use <code>git</code> for your flake, ensure to <code>git add</code> any project files after you first create them.

See also https://www.tweag.io/blog/2020-05-25-flakes/

<span id="Generate_flake.nix_file"></span>

====Générer un fichier flake.nix====

To start the basic usage of flake, run the flake command in the project directory:

<syntaxHighlight lang=text>

nix flake init

* <code>nixConfig</code> is an attribute set of values which reflect the [https://nixos.org/manual/nix/stable/command-ref/conf-file.html values given to nix.conf]. This can extend the normal behavior of a user's nix experience by adding flake-specific configuration, such as a binary cache.

==== nix run ====

== Using flakes with stable Nix ==

There exists the [https://github.com/edolstra/flake-compat flake-compat] library that you can use to shim <code>default.nix</code> and <code>shell.nix</code> files. It will download the inputs of the flake, pass them to the flake’s <code>outputs</code> function and return an attribute set containing <code>defaultNix</code> and <code>shellNix</code> attributes. The attributes will contain the output attribute set with an extra <code>default</code> attribute pointing to current platform’s <code>defaultPackage</code> (resp. <code>devShell</code> for <code>shellNix</code>).

Place the following into <code>default.nix</code> (for <code>shell.nix</code>, replace <code>defaultNix</code> with <code>shellNix</code>) to use the shim:

You can also use the lockfile to make updating the hashes easier using <code>nix flake lock --update-input flake-compat</code>. Add the following to your <code>flake.nix</code>:

 

  inputs.flake-compat = {

 

and add <code>flake-compat</code> to the arguments of <code>outputs</code> attribute. Then you will be able to use <code>default.nix</code> like the following:

 

    nodeName = lock.nodes.root.inputs.flake-compat;

 

 

If you want to access a flake from within a regular Nix expression on a system that has flakes enabled, you can use something like <code>(builtins.getFlake "/path/to/directory").packages.x86_64-linux.default</code>, where 'directory' is the directory that contains your <code>flake.nix</code>.

== Making your evaluations pure ==

Nix flakes run in pure evaluation mode, which is underdocumented. Some tips for now:

   inputs.nixpkgs.url = github:NixOS/nixpkgs/nixos-unstable;

 

<div lang="en" dir="ltr" class="mw-content-ltr">

<syntaxhighlight lang="nix">

{

  inputs.nixpkgs.url = github:NixOS/nixpkgs/nixos-unstable;

 

    };

   ...

 

 

<div lang="en" dir="ltr" class="mw-content-ltr">

{{Ic|nixos-rebuild}} also allows to specify different flake using the <code>--flake</code> flag (# is optional):

 

<syntaxhighlight lang="console">

$ sudo nixos-rebuild switch --flake .

 

<div lang="en" dir="ltr" class="mw-content-ltr">

By default nixos-rebuild will use the currents system hostname to lookup the right nixos configuration in <code>nixosConfigurations</code>. You can also override this by using appending it to the flake parameter:

 

<syntaxhighlight lang="console">

 

<div lang="en" dir="ltr" class="mw-content-ltr">

 

   --target-host mymachine-hostname \

 

<div lang="en" dir="ltr" class="mw-content-ltr">

{{warning|Remote building seems to have an issue that's [https://github.com/NixOS/nixpkgs/issues/134952#issuecomment-1367056358 resolved by setting the <code>--fast</code> flag].}}

 

<div lang="en" dir="ltr" class="mw-content-ltr">

 

{ inputs, ... }:

{

nix.registry = {

     nixpkgs.flake = inputs.nixpkgs;

This has the unfortunate side-effect of requiring import-from-derivation and slowing down build times, however it may greatly speed up almost every eval. Full-time flakes users may be able to just use <code>narHash = pkgs.narHash</code>.

== Super fast nix-shell ==

</div>

A feature of the nix Flake edition is that Nix evaluations are cached.

Running nix-shell can be a bit slow and take 1-3 seconds.

   inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";

 

   outputs =

    { nixpkgs, ... }:

     {

       /*

        This example assumes your system is x86_64-linux

       devShells.x86_64-linux =

          pkgs = nixpkgs.legacyPackages.x86_64-linux;

        in

        {

          default = pkgs.mkShell {

            packages = [ pkgs.hello ];

And finally, run <code>nix develop</code>. This is what replaces the old nix-shell invocation.

Exit and run again, this command should now be super fast.

=== Automatically switch nix shells with nix-direnv ===

You can easily switch nix shells when you cd into different projects with [https://github.com/nix-community/nix-direnv nix-direnv].

== Pushing Flakes to Cachix ==

== Build specific attributes in a flake repository ==

When in the repository top-level, run <code>nix build .#<attr></code>. It will look in the <code>legacyPackages</code> and <code>packages</code> output attributes for the corresponding derivation.

 

<syntaxHighlight lang=console>

 

<div lang="en" dir="ltr" class="mw-content-ltr">

=== Building flakes from a Git repo url with submodules ===

As per nix 2.9.1, git submodules in package <code>src</code>'s won't get copied to the nix store, this may cause the build to fail. To workaround this, use:

 

 

 

 

 

 

 

 

== Getting ''Instant'' System Flakes Repl ==

 

How to get a nix repl out of your system flake:

 

 

 

 

 

However, this won't be instant upon evaluation if any file changes have been done since your last configuration rebuild. Instead, if one puts:

 

nix.nixPath = let path = toString ./.; in [ "repl=${path}/repl.nix" "nixpkgs=${inputs.nixpkgs}" ];

 

In their system <code>flake.nix</code> configuration file, and includes the following file in their root directory flake as <code>repl.nix</code>:

</div>

 

  flake = builtins.getFlake (toString ./.);

// flake.nixosConfigurations

</syntaxHighlight>

 

(Don't forget to <code>git add repl.nix && nixos-rebuild  switch --flake "/etc/nixos"</code>)

 

source /etc/set-environment && nix repl $(echo $NIX_PATH | perl -pe 's|.*(/nix/store/.*-source/repl.nix).*|\1|')</syntaxHighlight>

 

This will launch a repl with access to <code>nixpkgs</code>, <code>lib</code>, and the <code>flake</code> options in a split of a second.

 

 

nix.nixPath = [ "nixpkgs=${inputs.nixpkgs}" ];

  repl_path = toString ./.;

 

 

 

When a git folder exists, flake will only copy files added in git to maximize reproducibility (this way if you forgot to add a local file in your repo, you will directly get an error when you try to compile it). However, for development purpose you may want to create an alternative flake file, for instance containing configuration for your preferred editors as described [https://discourse.nixos.org/t/local-personal-development-tools-with-flakes/22714/8 here]… of course without committing this file since it contains only your own preferred tools. You can do so by doing something like that (say for a file called <code>extra/flake.nix</code>):

* [https://nixos.org/manual/nix/unstable/command-ref/new-cli/nix3-flake.html Nix flake command reference manual] - Many additional details about flakes, and their parts.

* [https://www.youtube.com/watch?v=QXUlhnhuRX4&list=PLgknCdxP89RcGPTjngfNR9WmBgvD_xW0l Nix flakes 101: Introduction to nix flakes] (Jörg Thalheim, 2020)

* [https://github.com/NixOS/nix/blob/master/src/nix/flake.md spec describing flake inputs in more detail]

* [https://github.com/numtide/flake-utils flake-utils: Library to avoid some boiler-code when writing flakes]

* [https://zimbatm.com/NixFlakes/#direnv-integration zimbat's direnv article]