commit 6c47e7d5da028f171def976b0702413eb0ad95a1 · pyrox.dev/nixpkgs

+10 -8

nixos/doc/manual/administration/service-mgmt.chapter.md

···

       126
       126
        
       You can define services by adding them to `systemd.services`:

     

       127
       127
        
       

     

       128
       128
        
       ```nix

     

       129
       129
       -
       systemd.services.myservice = {

     

       130
       130
       -
         after = [ "network-online.target" ];

     

       131
       131
       -
         requires = [ "network-online.target" ];

     

       129
       129
       +
       {

     

       130
       130
       +
         systemd.services.myservice = {

     

       131
       131
       +
           after = [ "network-online.target" ];

     

       132
       132
       +
           requires = [ "network-online.target" ];

     

       132
       133
        
       

     

       133
       133
       -
         before = [ "multi-user.target" ];

     

       134
       134
       -
         wantedBy = [ "multi-user.target" ];

     

       134
       134
       +
           before = [ "multi-user.target" ];

     

       135
       135
       +
           wantedBy = [ "multi-user.target" ];

     

       135
       136
        
       

     

       136
       136
       -
         serviceConfig = {

     

       137
       137
       -
           ExecStart = "...";

     

       137
       137
       +
           serviceConfig = {

     

       138
       138
       +
             ExecStart = "...";

     

       139
       139
       +
           };

     

       138
       140
        
         };

     

       139
       139
       -
       };

     

       141
       141
       +
       }

     

       140
       142
        
       ```

     

       141
       143
        
       

     

       142
       144
        
       If you want to specify a multi-line script for `ExecStart`,

+1 -1

nixos/doc/manual/configuration/adding-custom-packages.section.md

···

       111
       111
        
           extraPkgs = pkgs: [

     

       112
       112
        
             # missing libraries here, e.g.: `pkgs.libepoxy`

     

       113
       113
        
           ];

     

       114
       114
       -
         }

     

       114
       114
       +
         };

     

       115
       115
        
       }

     

       116
       116
        
       ```

     

       117
       117

+1 -1

nixos/doc/manual/configuration/mattermost.chapter.md

···

       33
       33
        
       

     

       34
       34
        
           # For example, to disable auto-installation of prepackaged plugins.

     

       35
       35
        
           settings.PluginSettings.AutomaticPrepackagedPlugins = false;

     

       36
       36
       -
         }

     

       36
       36
       +
         };

     

       37
       37
        
       }

     

       38
       38
        
       ```

     

       39
       39

+6 -2

nixos/doc/manual/configuration/user-mgmt.chapter.md

···

       137
       137
        
       You can enable Userborn via:

     

       138
       138
        
       

     

       139
       139
        
       ```nix

     

       140
       140
       -
       services.userborn.enable = true;

     

       140
       140
       +
       {

     

       141
       141
       +
         services.userborn.enable = true;

     

       142
       142
       +
       }

     

       141
       143
        
       ```

     

       142
       144
        
       

     

       143
       145
        
       You can configure Userborn to store the password files

     
···

       145
       147
        
       location to `/etc`:

     

       146
       148
        
       

     

       147
       149
        
       ```nix

     

       148
       148
       -
       services.userborn.passwordFilesLocation = "/persistent/etc";

     

       150
       150
       +
       {

     

       151
       151
       +
         services.userborn.passwordFilesLocation = "/persistent/etc";

     

       152
       152
       +
       }

     

       149
       153
        
       ```

     

       150
       154
        
       

     

       151
       155
        
       This is useful when you store `/etc` on a `tmpfs` or if `/etc` is immutable

+100 -91

nixos/doc/manual/development/testing-hardware-features.section.md

···

       22
       22
        
       physical layer.

     

       23
       23
        
       

     

       24
       24
        
       ```nix

     

       25
       25
       -
       airgap =

     

       26
       26
       -
         { config, ... }:

     

       27
       27
       -
         {

     

       28
       28
       -
           networking.interfaces.eth1.ipv4.addresses = lib.mkForce [

     

       29
       29
       -
             {

     

       30
       30
       -
               address = "192.168.1.2";

     

       31
       31
       -
               prefixLength = 24;

     

       32
       32
       -
             }

     

       33
       33
       -
           ];

     

       34
       34
       -
           services.vwifi = {

     

       35
       35
       -
             server = {

     

       36
       36
       -
               enable = true;

     

       37
       37
       -
               ports.tcp = 8212;

     

       38
       38
       -
               # uncomment if you want to enable monitor mode on another node

     

       39
       39
       -
               # ports.spy = 8213;

     

       40
       40
       -
               openFirewall = true;

     

       25
       25
       +
       {

     

       26
       26
       +
         airgap =

     

       27
       27
       +
           { config, ... }:

     

       28
       28
       +
           {

     

       29
       29
       +
             networking.interfaces.eth1.ipv4.addresses = lib.mkForce [

     

       30
       30
       +
               {

     

       31
       31
       +
                 address = "192.168.1.2";

     

       32
       32
       +
                 prefixLength = 24;

     

       33
       33
       +
               }

     

       34
       34
       +
             ];

     

       35
       35
       +
             services.vwifi = {

     

       36
       36
       +
               server = {

     

       37
       37
       +
                 enable = true;

     

       38
       38
       +
                 ports.tcp = 8212;

     

       39
       39
       +
                 # uncomment if you want to enable monitor mode on another node

     

       40
       40
       +
                 # ports.spy = 8213;

     

       41
       41
       +
                 openFirewall = true;

     

       42
       42
       +
               };

     

       41
       43
        
             };

     

       42
       44
        
           };

     

       43
       43
       -
         };

     

       45
       45
       +
       }

     

       44
       46
        
       ```

     

       45
       47
        
       

     

       46
       48
        
       ### AP {#sec-nixos-test-wifi-ap}

     
···

       48
       50
        
       A node like this will act as a wireless access point in infrastructure mode.

     

       49
       51
        
       

     

       50
       52
        
       ```nix

     

       51
       51
       -
       ap =

     

       52
       52
       -
         { config, ... }:

     

       53
       53
       -
         {

     

       54
       54
       -
           networking.interfaces.eth1.ipv4.addresses = lib.mkForce [

     

       55
       55
       -
             {

     

       56
       56
       -
               address = "192.168.1.3";

     

       57
       57
       -
               prefixLength = 24;

     

       58
       58
       -
             }

     

       59
       59
       -
           ];

     

       60
       60
       -
           services.hostapd = {

     

       61
       61
       -
             enable = true;

     

       62
       62
       -
             radios.wlan0 = {

     

       63
       63
       -
               channel = 1;

     

       64
       64
       -
               networks.wlan0 = {

     

       65
       65
       -
                 ssid = "NixOS Test Wi-Fi Network";

     

       66
       66
       -
                 authentication = {

     

       67
       67
       -
                   mode = "wpa3-sae";

     

       68
       68
       -
                   saePasswords = [ { password = "supersecret"; } ];

     

       69
       69
       -
                   enableRecommendedPairwiseCiphers = true;

     

       53
       53
       +
       {

     

       54
       54
       +
         ap =

     

       55
       55
       +
           { config, ... }:

     

       56
       56
       +
           {

     

       57
       57
       +
             networking.interfaces.eth1.ipv4.addresses = lib.mkForce [

     

       58
       58
       +
               {

     

       59
       59
       +
                 address = "192.168.1.3";

     

       60
       60
       +
                 prefixLength = 24;

     

       61
       61
       +
               }

     

       62
       62
       +
             ];

     

       63
       63
       +
             services.hostapd = {

     

       64
       64
       +
               enable = true;

     

       65
       65
       +
               radios.wlan0 = {

     

       66
       66
       +
                 channel = 1;

     

       67
       67
       +
                 networks.wlan0 = {

     

       68
       68
       +
                   ssid = "NixOS Test Wi-Fi Network";

     

       69
       69
       +
                   authentication = {

     

       70
       70
       +
                     mode = "wpa3-sae";

     

       71
       71
       +
                     saePasswords = [ { password = "supersecret"; } ];

     

       72
       72
       +
                     enableRecommendedPairwiseCiphers = true;

     

       73
       73
       +
                   };

     

       70
       74
        
                 };

     

       71
       75
        
               };

     

       72
       76
        
             };

     

       73
       73
       -
           };

     

       74
       74
       -
           services.vwifi = {

     

       75
       75
       -
             module = {

     

       76
       76
       -
               enable = true;

     

       77
       77
       -
               macPrefix = "74:F8:F6:00:01";

     

       78
       78
       -
             };

     

       79
       79
       -
             client = {

     

       80
       80
       -
               enable = true;

     

       81
       81
       -
               serverAddress = "192.168.1.2";

     

       77
       77
       +
             services.vwifi = {

     

       78
       78
       +
               module = {

     

       79
       79
       +
                 enable = true;

     

       80
       80
       +
                 macPrefix = "74:F8:F6:00:01";

     

       81
       81
       +
               };

     

       82
       82
       +
               client = {

     

       83
       83
       +
                 enable = true;

     

       84
       84
       +
                 serverAddress = "192.168.1.2";

     

       85
       85
       +
               };

     

       82
       86
        
             };

     

       83
       87
        
           };

     

       84
       84
       -
         };

     

       88
       88
       +
       }

     

       85
       89
        
       ```

     

       86
       90
        
       

     

       87
       91
        
       ### Station {#sec-nixos-test-wifi-station}

     
···

       89
       93
        
       A node like this acts as a wireless client.

     

       90
       94
        
       

     

       91
       95
        
       ```nix

     

       92
       92
       -
       station =

     

       93
       93
       -
         { config, ... }:

     

       94
       94
       -
         {

     

       95
       95
       -
           networking.interfaces.eth1.ipv4.addresses = lib.mkForce [

     

       96
       96
       -
             {

     

       97
       97
       -
               address = "192.168.1.3";

     

       98
       98
       -
               prefixLength = 24;

     

       99
       99
       -
             }

     

       100
       100
       -
           ];

     

       101
       101
       -
           networking.wireless = {

     

       102
       102
       -
             # No, really, we want it enabled!

     

       103
       103
       -
             enable = lib.mkOverride 0 true;

     

       104
       104
       -
             interfaces = [ "wlan0" ];

     

       105
       105
       -
             networks = {

     

       106
       106
       -
               "NixOS Test Wi-Fi Network" = {

     

       107
       107
       -
                 psk = "supersecret";

     

       108
       108
       -
                 authProtocols = [ "SAE" ];

     

       96
       96
       +
       {

     

       97
       97
       +
         station =

     

       98
       98
       +
           { config, ... }:

     

       99
       99
       +
           {

     

       100
       100
       +
             networking.interfaces.eth1.ipv4.addresses = lib.mkForce [

     

       101
       101
       +
               {

     

       102
       102
       +
                 address = "192.168.1.3";

     

       103
       103
       +
                 prefixLength = 24;

     

       104
       104
       +
               }

     

       105
       105
       +
             ];

     

       106
       106
       +
             networking.wireless = {

     

       107
       107
       +
               # No, really, we want it enabled!

     

       108
       108
       +
               enable = lib.mkOverride 0 true;

     

       109
       109
       +
               interfaces = [ "wlan0" ];

     

       110
       110
       +
               networks = {

     

       111
       111
       +
                 "NixOS Test Wi-Fi Network" = {

     

       112
       112
       +
                   psk = "supersecret";

     

       113
       113
       +
                   authProtocols = [ "SAE" ];

     

       114
       114
       +
                 };

     

       109
       115
        
               };

     

       110
       116
        
             };

     

       111
       111
       -
           };

     

       112
       112
       -
           services.vwifi = {

     

       113
       113
       -
             module = {

     

       114
       114
       -
               enable = true;

     

       115
       115
       -
               macPrefix = "74:F8:F6:00:02";

     

       116
       116
       -
             };

     

       117
       117
       -
             client = {

     

       118
       118
       -
               enable = true;

     

       119
       119
       -
               serverAddress = "192.168.1.2";

     

       117
       117
       +
             services.vwifi = {

     

       118
       118
       +
               module = {

     

       119
       119
       +
                 enable = true;

     

       120
       120
       +
                 macPrefix = "74:F8:F6:00:02";

     

       121
       121
       +
               };

     

       122
       122
       +
               client = {

     

       123
       123
       +
                 enable = true;

     

       124
       124
       +
                 serverAddress = "192.168.1.2";

     

       125
       125
       +
               };

     

       120
       126
        
             };

     

       121
       127
        
           };

     

       122
       122
       -
         };

     

       128
       128
       +
       }

     

       123
       129
        
       ```

     

       124
       130
        
       

     

       125
       131
        
       ### Monitor {#sec-nixos-test-wifi-monitor}

     
···

       128
       134
        
       all packets broadcast by all other nodes through the spy interface.

     

       129
       135
        
       

     

       130
       136
        
       ```nix

     

       131
       131
       -
       monitor =

     

       132
       132
       -
         { config, ... }:

     

       133
       133
       -
         {

     

       134
       134
       -
           networking.interfaces.eth1.ipv4.addresses = lib.mkForce [

     

       135
       135
       -
             {

     

       136
       136
       -
               address = "192.168.1.4";

     

       137
       137
       -
               prefixLength = 24;

     

       138
       138
       -
             }

     

       139
       139
       -
           ];

     

       137
       137
       +
       {

     

       138
       138
       +
         monitor =

     

       139
       139
       +
           { config, ... }:

     

       140
       140
       +
           {

     

       141
       141
       +
             networking.interfaces.eth1.ipv4.addresses = lib.mkForce [

     

       142
       142
       +
               {

     

       143
       143
       +
                 address = "192.168.1.4";

     

       144
       144
       +
                 prefixLength = 24;

     

       145
       145
       +
               }

     

       146
       146
       +
             ];

     

       140
       147
        
       

     

       141
       141
       -
           services.vwifi = {

     

       142
       142
       -
             module = {

     

       143
       143
       -
               enable = true;

     

       144
       144
       -
               macPrefix = "74:F8:F6:00:03";

     

       145
       145
       -
             };

     

       146
       146
       -
             client = {

     

       147
       147
       -
               enable = true;

     

       148
       148
       -
               spy = true;

     

       149
       149
       -
               serverAddress = "192.168.1.2";

     

       148
       148
       +
             services.vwifi = {

     

       149
       149
       +
               module = {

     

       150
       150
       +
                 enable = true;

     

       151
       151
       +
                 macPrefix = "74:F8:F6:00:03";

     

       152
       152
       +
               };

     

       153
       153
       +
               client = {

     

       154
       154
       +
                 enable = true;

     

       155
       155
       +
                 spy = true;

     

       156
       156
       +
                 serverAddress = "192.168.1.2";

     

       157
       157
       +
               };

     

       150
       158
        
             };

     

       151
       159
        
           };

     

       160
       160
       +
       }

     

       152
       161
        
       ```

+2

nixos/doc/manual/installation/building-images-via-nixos-rebuild-build-image.chapter.md

···

       25
       25
        
       E.g. images for the cloud provider Linode use `grub2` as a bootloader by default. If you are using `systemd-boot` on other platforms and want to disable it for Linode only, you could use the following options:

     

       26
       26
        
       

     

       27
       27
        
       ``` nix

     

       28
       28
       +
       {

     

       28
       29
        
         image.modules.linode = {

     

       29
       30
        
           boot.loader.systemd-boot.enable = lib.mkForce false;

     

       30
       31
        
         };

     

       32
       32
       +
       }

     

       31
       33
        
       ```

+5 -3

nixos/doc/manual/release-notes/rl-2405.section.md

···

       243
       243
        
       - `azure-cli` now has extension support. For example, to install the `aks-preview` extension, use

     

       244
       244
        
       

     

       245
       245
        
         ```nix

     

       246
       246
       -
         environment.systemPackages = [

     

       247
       247
       -
           (azure-cli.withExtensions [ azure-cli.extensions.aks-preview ])

     

       248
       248
       -
         ];

     

       246
       246
       +
         {

     

       247
       247
       +
           environment.systemPackages = [

     

       248
       248
       +
             (azure-cli.withExtensions [ azure-cli.extensions.aks-preview ])

     

       249
       249
       +
           ];

     

       250
       250
       +
         }

     

       249
       251
        
         ```

     

       250
       252
        
         To make the `azure-cli` immutable and prevent clashes in case `azure-cli` is also installed via other package managers, some configuration files were moved into the derivation.

     

       251
       253
        
         This can be disabled by overriding `withImmutableConfig = false` when building `azure-cli`.

+21 -17

nixos/doc/manual/release-notes/rl-2411.section.md

···

       615
       615
        
         Then, follow the instructions on the [upstream release notes](https://github.com/majewsky/portunus/releases/tag/v2.0.0) to upgrade all existing user accounts to strong password hashes.

     

       616
       616
        
         If you need to upgrade to 24.11 without having completed the migration, consider the security implications of weak password hashes on your user accounts, and add the following to your configuration:

     

       617
       617
        
         ```nix

     

       618
       618
       -
         services.portunus.package      = pkgs.portunus.override { libxcrypt = pkgs.libxcrypt-legacy; };

     

       619
       619
       -
         services.portunus.ldap.package = pkgs.openldap.override { libxcrypt = pkgs.libxcrypt-legacy; };

     

       618
       618
       +
         {

     

       619
       619
       +
           services.portunus.package      = pkgs.portunus.override { libxcrypt = pkgs.libxcrypt-legacy; };

     

       620
       620
       +
           services.portunus.ldap.package = pkgs.openldap.override { libxcrypt = pkgs.libxcrypt-legacy; };

     

       621
       621
       +
         }

     

       620
       622
        
         ```

     

       621
       623
        
       

     

       622
       624
        
       - The default value of `services.kubernetes.kubelet.hostname` is now lowercased.

     
···

       956
       958
        
         - If you want to maintain the exact behavior of the option, use the following snippet

     

       957
       959
        
       

     

       958
       960
        
       ```nix

     

       959
       959
       -
       services.actkbd = let

     

       960
       960
       -
         volumeStep = "1%";

     

       961
       961
       -
       in {

     

       962
       962
       -
         enable = true;

     

       963
       963
       -
         bindings = [

     

       964
       964
       -
           # "Mute" media key

     

       965
       965
       -
           { keys = [ 113 ]; events = [ "key" ];       command = "${alsa-utils}/bin/amixer -q set Master toggle"; }

     

       961
       961
       +
       {

     

       962
       962
       +
         services.actkbd = let

     

       963
       963
       +
           volumeStep = "1%";

     

       964
       964
       +
         in {

     

       965
       965
       +
           enable = true;

     

       966
       966
       +
           bindings = [

     

       967
       967
       +
             # "Mute" media key

     

       968
       968
       +
             { keys = [ 113 ]; events = [ "key" ];       command = "${alsa-utils}/bin/amixer -q set Master toggle"; }

     

       966
       969
        
       

     

       967
       967
       -
           # "Lower Volume" media key

     

       968
       968
       -
           { keys = [ 114 ]; events = [ "key" "rep" ]; command = "${alsa-utils}/bin/amixer -q set Master ${volumeStep}- unmute"; }

     

       970
       970
       +
             # "Lower Volume" media key

     

       971
       971
       +
             { keys = [ 114 ]; events = [ "key" "rep" ]; command = "${alsa-utils}/bin/amixer -q set Master ${volumeStep}- unmute"; }

     

       969
       972
        
       

     

       970
       970
       -
           # "Raise Volume" media key

     

       971
       971
       -
           { keys = [ 115 ]; events = [ "key" "rep" ]; command = "${alsa-utils}/bin/amixer -q set Master ${volumeStep}+ unmute"; }

     

       973
       973
       +
             # "Raise Volume" media key

     

       974
       974
       +
             { keys = [ 115 ]; events = [ "key" "rep" ]; command = "${alsa-utils}/bin/amixer -q set Master ${volumeStep}+ unmute"; }

     

       972
       975
        
       

     

       973
       973
       -
           # "Mic Mute" media key

     

       974
       974
       -
           { keys = [ 190 ]; events = [ "key" ];       command = "${alsa-utils}/bin/amixer -q set Capture toggle"; }

     

       975
       975
       -
         ];

     

       976
       976
       -
       };

     

       976
       976
       +
             # "Mic Mute" media key

     

       977
       977
       +
             { keys = [ 190 ]; events = [ "key" ];       command = "${alsa-utils}/bin/amixer -q set Capture toggle"; }

     

       978
       978
       +
           ];

     

       979
       979
       +
         };

     

       980
       980
       +
       }

     

       977
       981
        
       ```

     

       978
       982
        
       

     

       979
       983
        
       ### `hardware.deviceTree.overlays` compatible string matching {#sec-release-24.11-migration-dto-compatible}

+15 -11

nixos/doc/manual/release-notes/rl-2505.section.md

···

       355
       355
        
       - To avoid delaying user logins unnecessarily the `multi-user.target` is no longer ordered after `network-online.target`.

     

       356
       356
        
         System services requiring a connection to start correctly must explicitly state so, i.e.

     

       357
       357
        
         ```nix

     

       358
       358
       -
         systemd.services.<name> = {

     

       359
       359
       -
           wants = [ "network-online.target" ];

     

       360
       360
       -
           after = [ "network-online.target" ];

     

       361
       361
       -
         };

     

       358
       358
       +
         {

     

       359
       359
       +
           systemd.services."<name>" = {

     

       360
       360
       +
             wants = [ "network-online.target" ];

     

       361
       361
       +
             after = [ "network-online.target" ];

     

       362
       362
       +
           };

     

       363
       363
       +
         }

     

       362
       364
        
         ```

     

       363
       365
        
         This changed follows a deprecation period of one year started in NixOS 24.05 (see [PR #283818](https://github.com/NixOS/nixpkgs/pull/283818)).

     

       364
       366
        
       

     
···

       457
       459
        
         Example:

     

       458
       460
        
       

     

       459
       461
        
         ```nix

     

       460
       460
       -
         services.mysql = {

     

       461
       461
       -
           enable = true;

     

       462
       462
       -
           galeraCluster = {

     

       462
       462
       +
         {

     

       463
       463
       +
           services.mysql = {

     

       463
       464
        
             enable = true;

     

       464
       464
       -
             localName = "Node 1";

     

       465
       465
       -
             localAddress = "galera_01";

     

       466
       466
       -
             nodeAddresses = [ "galera_01" "galera_02" "galera_03"];

     

       465
       465
       +
             galeraCluster = {

     

       466
       466
       +
               enable = true;

     

       467
       467
       +
               localName = "Node 1";

     

       468
       468
       +
               localAddress = "galera_01";

     

       469
       469
       +
               nodeAddresses = [ "galera_01" "galera_02" "galera_03"];

     

       470
       470
       +
             };

     

       467
       471
        
           };

     

       468
       468
       -
         };

     

       472
       472
       +
         }

     

       469
       473
        
         ```

     

       470
       474
        
       

     

       471
       475
        
       - systemd's {manpage}`systemd-ssh-generator(8)` now works out of the box on NixOS.

+32 -30

nixos/modules/services/databases/postgresql.md

···

       94
       94
        
       `ensureUsers` is run in `postgresql-setup`, so this is where `postStart` must be added to:

     

       95
       95
        
       

     

       96
       96
        
       ```nix

     

       97
       97
       -
         {

     

       98
       98
       -
           systemd.services.postgresql-setup.postStart = ''

     

       99
       99
       -
             psql service1 -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       100
       100
       -
             psql service1 -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       101
       101
       -
             # ....

     

       102
       102
       -
           '';

     

       103
       103
       -
         }

     

       97
       97
       +
       {

     

       98
       98
       +
         systemd.services.postgresql-setup.postStart = ''

     

       99
       99
       +
           psql service1 -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       100
       100
       +
           psql service1 -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       101
       101
       +
           # ....

     

       102
       102
       +
         '';

     

       103
       103
       +
       }

     

       104
       104
        
       ```

     

       105
       105
        
       

     

       106
       106
        
       #### in intermediate oneshot service {#module-services-postgres-initializing-extra-permissions-superuser-oneshot}

     
···

       114
       114
        
       Both can lead to unexpected errors either during initial database creation or restore, when using `postgresql.service`.

     

       115
       115
        
       

     

       116
       116
        
       ```nix

     

       117
       117
       -
         {

     

       118
       118
       -
           systemd.services."migrate-service1-db1" = {

     

       119
       119
       -
             serviceConfig.Type = "oneshot";

     

       120
       120
       -
             requiredBy = "service1.service";

     

       121
       121
       -
             before = "service1.service";

     

       122
       122
       -
             after = "postgresql.target";

     

       123
       123
       -
             serviceConfig.User = "postgres";

     

       124
       124
       -
             environment.PGPORT = toString services.postgresql.settings.port;

     

       125
       125
       -
             path = [ postgresql ];

     

       126
       126
       -
             script = ''

     

       127
       127
       -
               psql service1 -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       128
       128
       -
               psql service1 -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       129
       129
       -
               # ....

     

       130
       130
       -
             '';

     

       131
       131
       -
           };

     

       132
       132
       -
         }

     

       117
       117
       +
       {

     

       118
       118
       +
         systemd.services."migrate-service1-db1" = {

     

       119
       119
       +
           serviceConfig.Type = "oneshot";

     

       120
       120
       +
           requiredBy = "service1.service";

     

       121
       121
       +
           before = "service1.service";

     

       122
       122
       +
           after = "postgresql.target";

     

       123
       123
       +
           serviceConfig.User = "postgres";

     

       124
       124
       +
           environment.PGPORT = toString services.postgresql.settings.port;

     

       125
       125
       +
           path = [ postgresql ];

     

       126
       126
       +
           script = ''

     

       127
       127
       +
             psql service1 -c 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "extraUser1"'

     

       128
       128
       +
             psql service1 -c 'GRANT SELECT ON ALL SEQUENCES IN SCHEMA public TO "extraUser1"'

     

       129
       129
       +
             # ....

     

       130
       130
       +
           '';

     

       131
       131
       +
         };

     

       132
       132
       +
       }

     

       133
       133
        
       ```

     

       134
       134
        
       

     

       135
       135
        
       ## Authentication {#module-services-postgres-authentication}

     
···

       147
       147
        
       You can then use [](#opt-services.postgresql.identMap) to define the map and [](#opt-services.postgresql.authentication) to enable it:

     

       148
       148
        
       

     

       149
       149
        
       ```nix

     

       150
       150
       -
       services.postgresql = {

     

       151
       151
       -
         identMap = ''

     

       152
       152
       -
           admin root admin

     

       153
       153
       -
         '';

     

       154
       154
       -
         authentication = ''

     

       155
       155
       -
           local all admin peer map=admin

     

       156
       156
       -
         '';

     

       150
       150
       +
       {

     

       151
       151
       +
         services.postgresql = {

     

       152
       152
       +
           identMap = ''

     

       153
       153
       +
             admin root admin

     

       154
       154
       +
           '';

     

       155
       155
       +
           authentication = ''

     

       156
       156
       +
             local all admin peer map=admin

     

       157
       157
       +
           '';

     

       158
       158
       +
         };

     

       157
       159
        
       }

     

       158
       160
        
       ```

     

       159
       161

+3 -1

nixos/modules/services/misc/paisa.md

···

       21
       21
        
       access to the command at runtime.

     

       22
       22
        
       

     

       23
       23
        
       ```nix

     

       24
       24
       -
       systemd.services.paisa.path = [ pkgs.hledger ];

     

       24
       24
       +
       {

     

       25
       25
       +
         systemd.services.paisa.path = [ pkgs.hledger ];

     

       26
       26
       +
       }

     

       25
       27
        
       ```

     

       26
       28
        
       

     

       27
       29
        
       ::: {.note}

+1 -1

nixos/modules/services/monitoring/glances.md

···

       16
       16
        
           enable = true;

     

       17
       17
        
           openFirewall = true;

     

       18
       18
        
         };

     

       19
       19
       -
       };

     

       19
       19
       +
       }

     

       20
       20
        
       ```

+1 -1

nixos/modules/services/networking/crab-hole.md

···

       103
       103
        
             certificate = ./dns.example.com.crt;

     

       104
       104
        
             key = "/dns.example.com.key";

     

       105
       105
        
             # optional (default = 3000)

     

       106
       106
       -
             timeout_ms = 3000

     

       106
       106
       +
             timeout_ms = 3000;

     

       107
       107
        
           }

     

       108
       108
        
         ];

     

       109
       109
        
       }

+7 -5

nixos/modules/services/networking/jotta-cli.md

···

       15
       15
        
       ## Example Configuration {#module-services-jotta-cli-example-configuration}

     

       16
       16
        
       

     

       17
       17
        
       ```nix

     

       18
       18
       -
       services.jotta-cli = {

     

       19
       19
       -
         enable = true;

     

       20
       20
       -
         options = [ "slow" ];

     

       21
       21
       -
         package = pkgs.jotta-cli;

     

       22
       22
       -
       };

     

       18
       18
       +
       {

     

       19
       19
       +
         services.jotta-cli = {

     

       20
       20
       +
           enable = true;

     

       21
       21
       +
           options = [ "slow" ];

     

       22
       22
       +
           package = pkgs.jotta-cli;

     

       23
       23
       +
         };

     

       24
       24
       +
       }

     

       23
       25
        
       ```

     

       24
       26
        
       

     

       25
       27
        
       This uses `jotta-cli` and `jottad` from the `pkgs.jotta-cli` package and starts `jottad` in low memory mode.

+23 -21

nixos/modules/services/networking/netbird/server.md

···

       9
       9
        
       There are quite a few settings that need to be passed to Netbird for it to function, and a minimal config looks like :

     

       10
       10
        
       

     

       11
       11
        
       ```nix

     

       12
       12
       -
       services.netbird.server = {

     

       13
       13
       -
         enable = true;

     

       12
       12
       +
       {

     

       13
       13
       +
         services.netbird.server = {

     

       14
       14
       +
           enable = true;

     

       14
       15
        
       

     

       15
       15
       -
         domain = "netbird.example.selfhosted";

     

       16
       16
       +
           domain = "netbird.example.selfhosted";

     

       16
       17
        
       

     

       17
       17
       -
         enableNginx = true;

     

       18
       18
       +
           enableNginx = true;

     

       18
       19
        
       

     

       19
       19
       -
         coturn = {

     

       20
       20
       -
           enable = true;

     

       20
       20
       +
           coturn = {

     

       21
       21
       +
             enable = true;

     

       21
       22
        
       

     

       22
       22
       -
           passwordFile = "/path/to/a/secret/password";

     

       23
       23
       -
         };

     

       23
       23
       +
             passwordFile = "/path/to/a/secret/password";

     

       24
       24
       +
           };

     

       24
       25
        
       

     

       25
       25
       -
         management = {

     

       26
       26
       -
           oidcConfigEndpoint = "https://sso.example.selfhosted/oauth2/openid/netbird/.well-known/openid-configuration";

     

       26
       26
       +
           management = {

     

       27
       27
       +
             oidcConfigEndpoint = "https://sso.example.selfhosted/oauth2/openid/netbird/.well-known/openid-configuration";

     

       27
       28
        
       

     

       28
       28
       -
           settings = {

     

       29
       29
       -
             TURNConfig = {

     

       30
       30
       -
               Turns = [

     

       31
       31
       -
                 {

     

       32
       32
       -
                   Proto = "udp";

     

       33
       33
       -
                   URI = "turn:netbird.example.selfhosted:3478";

     

       34
       34
       -
                   Username = "netbird";

     

       35
       35
       -
                   Password._secret = "/path/to/a/secret/password";

     

       36
       36
       -
                 }

     

       37
       37
       -
               ];

     

       29
       29
       +
             settings = {

     

       30
       30
       +
               TURNConfig = {

     

       31
       31
       +
                 Turns = [

     

       32
       32
       +
                   {

     

       33
       33
       +
                     Proto = "udp";

     

       34
       34
       +
                     URI = "turn:netbird.example.selfhosted:3478";

     

       35
       35
       +
                     Username = "netbird";

     

       36
       36
       +
                     Password._secret = "/path/to/a/secret/password";

     

       37
       37
       +
                   }

     

       38
       38
       +
                 ];

     

       39
       39
       +
               };

     

       38
       40
        
             };

     

       39
       41
        
           };

     

       40
       42
        
         };

     

       41
       41
       -
       };

     

       43
       43
       +
       }

     

       42
       44
        
       ```

+10 -11

nixos/modules/services/networking/pihole-ftl.md

···

       99
       99
        
       {

     

       100
       100
        
         services.pihole-ftl = {

     

       101
       101
        
           settings.misc.dnsmasq_lines = [

     

       102
       102
       -
               # Specify the secondary interface

     

       103
       103
       -
               "interface=enp1s0"

     

       104
       104
       -
               # A different device is the router on this network, e.g. the one

     

       105
       105
       -
               # provided by your ISP

     

       106
       106
       -
               "dhcp-option=enp1s0,option:router,192.168.0.1"

     

       107
       107
       -
               # Specify the IPv4 ranges to allocate, with a 1-day lease time

     

       108
       108
       -
               "dhcp-range=enp1s0,192.168.0.10,192.168.0.253,1d"

     

       109
       109
       -
               # Enable IPv6

     

       110
       110
       -
               "dhcp-range=::f,::ff,constructor:enp1s0,ra-names,ra-stateless"

     

       111
       111
       -
             ];

     

       112
       112
       -
           };

     

       102
       102
       +
             # Specify the secondary interface

     

       103
       103
       +
             "interface=enp1s0"

     

       104
       104
       +
             # A different device is the router on this network, e.g. the one

     

       105
       105
       +
             # provided by your ISP

     

       106
       106
       +
             "dhcp-option=enp1s0,option:router,192.168.0.1"

     

       107
       107
       +
             # Specify the IPv4 ranges to allocate, with a 1-day lease time

     

       108
       108
       +
             "dhcp-range=enp1s0,192.168.0.10,192.168.0.253,1d"

     

       109
       109
       +
             # Enable IPv6

     

       110
       110
       +
             "dhcp-range=::f,::ff,constructor:enp1s0,ra-names,ra-stateless"

     

       111
       111
       +
           ];

     

       113
       112
        
         };

     

       114
       113
        
       }

     

       115
       114
        
       ```

+1 -1

nixos/modules/services/system/kerberos/kerberos-server.md

···

       24
       24
        
               admin_server = "kerberos.example.com";

     

       25
       25
        
             };

     

       26
       26
        
           };

     

       27
       27
       -
         }

     

       27
       27
       +
         };

     

       28
       28
        
       

     

       29
       29
        
         services.kerberos-server = {

     

       30
       30
        
           enable = true;

+5 -3

nixos/modules/services/web-apps/nextcloud.md

···

       208
       208
        
           the cache size to zero:

     

       209
       209
        
       

     

       210
       210
        
           ```nix

     

       211
       211
       -
           services.nextcloud.phpOptions."realpath_cache_size" = "0";

     

       211
       211
       +
           {

     

       212
       212
       +
             services.nextcloud.phpOptions."realpath_cache_size" = "0";

     

       213
       213
       +
           }

     

       212
       214
        
           ```

     

       213
       215
        
       

     

       214
       216
        
         - **Empty Files on chunked uploads**

     
···

       286
       288
        
       

     

       287
       289
        
       ```nix

     

       288
       290
        
       { config, pkgs, ... }: {

     

       289
       289
       -
         services.nextcloud.extraApps = with config.services.nextcloud.package.packages.apps; [

     

       291
       291
       +
         services.nextcloud.extraApps = with config.services.nextcloud.package.packages.apps; {

     

       290
       292
        
           inherit user_oidc calendar contacts;

     

       291
       291
       -
         ];

     

       293
       293
       +
         };

     

       292
       294
        
       }

     

       293
       295
        
       ```

     

       294
       296

+2 -2

nixos/modules/services/web-apps/szurubooru.md

···

       40
       40
        
       

     

       41
       41
        
           server = {

     

       42
       42
        
             port = 8080;

     

       43
       43
       -
             ...

     

       43
       43
       +
             # ...

     

       44
       44
        
           };

     

       45
       45
        
       

     

       46
       46
       -
           ...

     

       46
       46
       +
           # ...

     

       47
       47
        
         };

     

       48
       48
        
       

     

       49
       49
        
         services.nginx.virtualHosts."szurubooru.domain.tld" = {

+18 -14

pkgs/applications/networking/cluster/k3s/docs/examples/EXTERNAL_CONTAINERD.md

···

       6
       6
        
       ## Configure Containerd

     

       7
       7
        
       

     

       8
       8
        
       ```nix

     

       9
       9
       -
       virtualisation.containerd = {

     

       10
       10
       -
         enable = true;

     

       11
       11
       -
         settings.plugins."io.containerd.grpc.v1.cri".cni = {

     

       12
       12
       -
           bin_dir = "/var/lib/rancher/k3s/data/current/bin";

     

       13
       13
       -
           conf_dir = "/var/lib/rancher/k3s/agent/etc/cni/net.d";

     

       14
       14
       -
         };

     

       15
       15
       -
         # Optionally, configure containerd to use the k3s pause image

     

       16
       16
       -
         settings.plugins."io.containerd.grpc.v1.cri" = {

     

       17
       17
       -
           sandbox_image = "docker.io/rancher/mirrored-pause:3.6";

     

       9
       9
       +
       {

     

       10
       10
       +
         virtualisation.containerd = {

     

       11
       11
       +
           enable = true;

     

       12
       12
       +
           settings.plugins."io.containerd.grpc.v1.cri".cni = {

     

       13
       13
       +
             bin_dir = "/var/lib/rancher/k3s/data/current/bin";

     

       14
       14
       +
             conf_dir = "/var/lib/rancher/k3s/agent/etc/cni/net.d";

     

       15
       15
       +
           };

     

       16
       16
       +
           # Optionally, configure containerd to use the k3s pause image

     

       17
       17
       +
           settings.plugins."io.containerd.grpc.v1.cri" = {

     

       18
       18
       +
             sandbox_image = "docker.io/rancher/mirrored-pause:3.6";

     

       19
       19
       +
           };

     

       18
       20
        
         };

     

       19
       19
       -
       };

     

       21
       21
       +
       }

     

       20
       22
        
       ```

     

       21
       23
        
       

     

       22
       24
        
       ## Configure k3s

     

       23
       25
        
       

     

       24
       26
        
       ```nix

     

       25
       25
       -
       services.k3s = {

     

       26
       26
       -
         enable = true;

     

       27
       27
       -
         extraFlags = [ "--container-runtime-endpoint unix:///run/containerd/containerd.sock" ];

     

       28
       28
       -
       };

     

       27
       27
       +
       {

     

       28
       28
       +
         services.k3s = {

     

       29
       29
       +
           enable = true;

     

       30
       30
       +
           extraFlags = [ "--container-runtime-endpoint unix:///run/containerd/containerd.sock" ];

     

       31
       31
       +
         };

     

       32
       32
       +
       }

     

       29
       33
        
       ```

     

       30
       34
        
       

     

       31
       35
        
       ## Importing Container Images

+8 -3

pkgs/by-name/README.md

···

       99
       99
        
       

     

       100
       100
        
       ```nix

     

       101
       101
        
       # all-packages.nix

     

       102
       102
       -
       fooWithBaz = foo.override {

     

       103
       103
       -
         bar = baz;

     

       104
       104
       -
       };

     

       102
       102
       +
       {

     

       103
       103
       +
         fooWithBaz = foo.override {

     

       104
       104
       +
           bar = baz;

     

       105
       105
       +
         };

     

       106
       106
       +
       }

     

       107
       107
       +
       ```

     

       108
       108
       +
       

     

       109
       109
       +
       ```nix

     

       105
       110
        
       # turned into pkgs/by-name/fo/fooWithBaz/package.nix with:

     

       106
       111
        
       {

     

       107
       112
        
         foo,

+5 -1

pkgs/by-name/az/azure-cli/README.md

···

       56
       56
        
       Based on this, you can add an attribute to `extensions-manual.nix`:

     

       57
       57
        
       

     

       58
       58
        
       ```nix

     

       59
       59
       +
       {

     

       59
       60
        
         azure-devops = mkAzExtension {

     

       60
       61
        
           pname = "azure-devops";

     

       61
       62
        
           version = "1.0.0";

     
···

       67
       68
        
           ];

     

       68
       69
        
           meta.maintainers = with lib.maintainers; [ katexochen ];

     

       69
       70
        
         };

     

       71
       71
       +
       }

     

       70
       72
        
       ```

     

       71
       73
        
       

     

       72
       74
        
       * The attribute name should be the same as `pname`.

     
···

       113
       115
        
       this example:

     

       114
       116
        
       

     

       115
       117
        
       ```nix

     

       116
       116
       -
       blockchain = throw "The 'blockchain' extension for azure-cli was deprecated upstream"; # Added 2024-04-26

     

       118
       118
       +
       {

     

       119
       119
       +
         blockchain = throw "The 'blockchain' extension for azure-cli was deprecated upstream"; # Added 2024-04-26

     

       120
       120
       +
       }

     

       117
       121
        
       ```

+2 -1

pkgs/servers/home-assistant/custom-components/README.md

···

       80
       80
        
       can be ignored on a per requirement basis.

     

       81
       81
        
       

     

       82
       82
        
       ```nix

     

       83
       83
       +
       {

     

       83
       84
        
         dependencies = [

     

       84
       85
        
           pyemvue

     

       85
       86
        
         ];

     
···

       88
       89
        
         ignoreVersionRequirement = [

     

       89
       90
        
           "pyemvue"

     

       90
       91
        
         ];

     

       92
       92
       +
       }

     

       91
       93
        
       ```

     

       92
       92
       -
       `