micro SD card image

[Diax170]

I'm trying to get NixOS working on my Raspberry Pi and create a custom SD card image I can boot it from. Normally you would do it like this:

flake.nix:

{
  description = "Build image";
  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-22.11";
  outputs = { self, nixpkgs }: rec {
    nixosConfigurations.rpi2 = nixpkgs.lib.nixosSystem {
      modules = [
        "${nixpkgs}/nixos/modules/installer/sd-card/sd-image-raspberrypi.nix"
        {
          nixpkgs.config.allowUnsupportedSystem = true;
          nixpkgs.hostPlatform.system = "armv7l-linux";
          nixpkgs.buildPlatform.system = "x86_64-linux"; #If you build on x86 other wise changes this.
          # ... extra configs as above
        }
      ];
    };
    images.rpi2 = nixosConfigurations.rpi2.config.system.build.sdImage;
  };
}

and build like this: nix build .#images.rpi2

but if I wanna reuse my Den config how can I expose the images attribute alongside nixosConfigurations?

I use Den with flake-file and flake-parts if it matters

[MLuc24]

Nothing about the sd-image side changes — the installer module, allowUnsupportedSystem and the two platform settings are ordinary NixOS module content, so they go into the host's aspect exactly as you have them.

The only part that differs is where you reach the result from. Den exposes the configurations under den.flake, as the migration guide's final flake shows:

inherit (den.flake) nixosConfigurations darwinConfigurations;

so the image output becomes the same expression you already have, one attribute deeper:

images.rpi2 = den.flake.nixosConfigurations.rpi2.config.system.build.sdImage;

and nix build .#images.rpi2 works as before.

If you would rather not have that line in flake.nix at all, Den can define flake outputs from inside modules/ — the guide's last example reduces the whole outputs to .config.flake once everything is declared that way. Either shape is fine; the first is a smaller step from where you are.

[Diax170]

Okay so I see that I would add this to the snippet from migration tutorial:

  outputs = inputs:
  let
   den = (inputs.nixpkgs.lib.evalModules {
     modules = [ (inputs.import-tree ./modules) ];
     specialArgs.inputs = inputs;
   }).config;
  in
  {
    inherit (den.flake) nixosConfigurations darwinConfigurations;

    # this is what I'm supposed to add
    images.rpi2 = den.flake.nixosConfigurations.rpi2.config.system.build.sdImage;
  };

but the issue is that, as I mentioned, I use the flake-parts mkFlake (I use perSystem in my config pretty frequently), and those don't provide the den attribute:

  outputs = inputs: inputs.flake-parts.lib.mkFlake { inherit inputs; } (inputs.import-tree ./modules);

is there a way to add the images output while preserving the flake-parts perSystem functionality?

[Diax170]

You also mention this

Den can define flake outputs from inside modules/

I found this line in the migration guide:

Even more, if you have defined all flake outputs as aspect-oriented flake outputs inside modules/ your final flake.nix becomes: ...

But I couldn't find an explanation on how are those aspect-oriented flake outputs supposed to work. I don't think they're even documented anywhere

[Diax170]

Never mind, I did it with flake-parts:

{ config, ... }:
{
  flake.images.oliserver = self.nixosConfigurations.oliserver.config.system.build.sdImage;
}

[fmway]

I've the same approach, but by using some den features.

{ den, lib, config, inputs, ... }:
{
  den.schema.host.options = {
    sdImage = lib.mkEnableOption "Set to true if you want to add sdImage to flake.images.<host>";
  };
  den.schema.host.includes = [
    den.policies.sd-image-to-flake
  ];
  den.policies.sd-image-to-flake = { host, ... }:
    lib.optional (host.sdImage)
      (den.lib.policy.resolve.to "flake" {
        sdImage.name = host.name;
        sdImage.package = (lib.getAttrFromPath (host.intoAttr) config.flake).config.system.build.sdImage;
      });
  den.schema.flake.includes = [
    ({ sdImage, ... }: {
      flake.flake.images.${sdImage.name} = sdImage.package;
    })
  ];

  # USAGE:
  den.hosts.armv7l-linux.rpi2.sdImage = true;
  den.aspects.rpi2 = {
    nixos.imports = [
      "${inputs.nixpkgs}/nixos/modules/installer/sd-card/sd-image-raspberrypi.nix"
      {
        nixpkgs.config.allowUnsupportedSystem = true;
        nixpkgs.buildPlatform.system = "x86_64-linux"; #If you build on x86 other wise changes this.
        # ... extra configs as above
      }
    ];
  };
}

There's more code now, but I think it's pretty den-able :)

[fmway]

Oh, wait. I pasted the wrong code. Sorry.

EDIT:
Eh, it's the right code. Well i don't really know what the problem is. Seems the conditional always to be true.

[fmway]

Hmm, after taking another look, it seems like it’s just a conflict between options, you set grub to true, whereas sd-image requires grub to false (maybe). I think the solution is simply this:

{
  den.aspects.host.boot.grub = {
    nixos = { host, ... }:
    {
      boot.loader.grub.enable = !host.sdImage;
    };
  };
}

[Diax170]

no, the thing is that the sd-image-raspberrypi module gets included for the wrong host (olipc) if I write sdImage = true in oliserver. see the output again. the pi (oliserver) config doesn't change boot.loader.grub.enable to true anywhere.. olipc is the one enabling grub. i will commit my wip pi config once I'm home

[Diax170]

alright see https://codeberg.org/OliMoli/nix-dots/src/branch/broken

[fmway]

alright see https://codeberg.org/OliMoli/nix-dots/src/branch/broken

Sorry for the late reply. My mistake, i misunderstood how policy.resolve.to works. I don't really know how it works, but { host; }: policy.resolve.to "flake" is already defined inside the internal den pipeline. Looks like that earlier code overrides the internal pipeline, that's probably why you're getting the warning too.

Here are two potential approaches you can try:

1. Map all hosts directly instead of using resolve.to

   {
     # without policies
     den.aspects.sd-image = {
       includes = builtins.concatMap (system: builtins.concatMap (host:
         lib.optional host.my.sdImage {
           flake.flake.images.${host.name} = (lib.getAttrFromPath host.intoAttr config.flake).config.system.build.sdImage;
         }
       ) (builtins.attrValues den.hosts.${system})) den.systems;
     };
     den.schema.flake.includes = [
       den.aspects.sd-image
     ];
     
     # with policies
     den.policies.sd-image-to-flake = _:  builtins.concatMap (system: builtins.concatMap (host:
       lib.optional host.my.sdImage (den.lib.policy.include {
         flake.flake.images.${host.name} = (lib.getAttrFromPath host.intoAttr config.flake).config.system.build.sdImage;
       })
     ) (builtins.attrValues den.hosts.${system})) den.systems;
     den.schema.flake.includes = [
       den.policies.sd-image-to-flake
     ];
   }

2. expose via legacyPackages.<system>.images.<host> . I'm not familiar with sd-image, but i'd prefer this option since the image is a derivation. Placing derivations under legacyPackages (or packages/apps/another per-system) seems like the cleaner convention.

   {
     # without policies
     den.aspects.sd-image = { system, ... }: let
       buildPlatform.system = system;
     in {
       includes = builtins.concatMap (system: builtins.concatMap (host:
         lib.optional host.my.sdImage {
           legacyPackages.images.${host.name} = (host.instantiate {
             inherit system;
             modules = [
               host.mainModule
               { nixpkgs.buildPlatform = buildPlatform; }
             ];
           }).config.system.build.sdImage;
         }
       ) (builtins.attrValues den.hosts.${system})) den.systems;
     };
     den.schema.flake-system.includes = [
       den.aspects.sd-image
     ];
     
     # with policies
     den.policies.sd-image-to-packages = { system, ... }: let
       buildPlatform.system = system;
     in builtins.concatMap (system: builtins.concatMap (host:
       lib.optional host.my.sdImage (den.lib.policy.include {
         legacyPackages.images.${host.name} = (host.instantiate {
           inherit system;
           modules = [
             host.mainModule
             { nixpkgs.buildPlatform = buildPlatform; }
           ];
         }).config.system.build.sdImage;
       })
     ) (builtins.attrValues den.hosts.${system})) den.systems;
     den.schema.flake-system.includes = [
       den.policies.sd-image-to-packages
     ];
   }

Note: I've included variations for both approaches (with and without policies). Basically both will produce the same output.