dns + keybinding consolidation

This commit is contained in:
ari committed 2026-09-21 10:52:32 -04:00
1 parent df46627173
commit f8444b1549
23 files changed
+612 -109

No files matched your search

+74
View File
@@ -0,0 +1,74 @@
# Aggregates `skyg.dns.resolved` across every nixosConfiguration into the shape
# the OpenWrt generator consumes (`generalMappings`).
#
# Usage:
# aggregate = import ./modules/dns-aggregate.nix { inherit lib; };
# aggregate.records self.nixosConfigurations # -> [ { ip; domains; ... } ]
# aggregate.json self.nixosConfigurations # -> { generalMappings = [...]; }
#
# Evaluation fails if the same name is mapped to two different addresses on any
# host, so drift between hosts is caught at `nix eval` / `nix flake check` time.
{ lib }:
let
# Per-host records, tagged with the config name they came from.
collect = nixosConfigurations:
lib.flatten (lib.mapAttrsToList
(cfgName: sys:
map (r: r // { configName = cfgName; })
(sys.config.skyg.dns.resolved or [ ]))
nixosConfigurations);
# name -> list of { ip, wildcard, source, host, configName }
byName = all:
lib.foldl'
(acc: r: lib.foldl'
(a: name: a // { ${name} = (a.${name} or [ ]) ++ [ r ]; })
acc
r.names)
{ }
all;
conflicts = all:
lib.filterAttrs
(_: entries: lib.length (lib.unique (map (e: e.ip) entries)) > 1)
(byName all);
checkConflicts = all:
let bad = conflicts all;
in
if bad == { }
then all
else
throw ''
skyg.dns: conflicting DNS records across hosts:
${lib.concatStringsSep "\n" (lib.mapAttrsToList
(name: entries: " ${name} -> ${lib.concatStringsSep ", " (map
(e: "${e.ip} (${e.configName}: ${e.source})") entries)}")
bad)}
'';
# Collapse to one entry per (ip, wildcard) pair, with sorted unique names.
records = nixosConfigurations:
let
all = checkConflicts (collect nixosConfigurations);
groups = lib.groupBy (r: "${r.ip}|${lib.boolToString r.wildcard}") all;
in
lib.sort (a: b: a.ip < b.ip) (lib.mapAttrsToList
(_: entries: {
ip = (lib.head entries).ip;
wildcard = (lib.head entries).wildcard;
domains = lib.sort (a: b: a < b) (lib.unique (lib.concatMap (e: e.names) entries));
sources = lib.sort (a: b: a < b) (lib.unique (map (e: "${e.configName}:${e.source}") entries));
})
groups);
in
{
inherit records;
# The fragment merged into the router's (secret) config JSON at deploy time.
json = nixosConfigurations: {
generalMappings = map (r: { inherit (r) ip domains wildcard; }) (records nixosConfigurations);
};
}
@@ -23,6 +23,28 @@ let
# When composeFile is set, networks/volumes/extraConfig declared alongside it
# are rendered as a base overrides file merged in via an earlier -f flag, so
# the composeFile's own definitions win on any overlapping keys.
# ---- internal DNS (skyg.dns) ----------------------------------------------
# Every service with dns.names set contributes a record. The address is taken
# from dns.ip when given, otherwise derived from the service's `networks`
# mapping (the compose form `{ lan.ipv4_address = "10.0.101.2"; }`).
serviceStaticIps = svcCfg:
if builtins.isAttrs svcCfg.networks
then lib.filter (v: v != null) (lib.mapAttrsToList (_: n: n.ipv4_address or null) svcCfg.networks)
else [ ];
dnsServices = lib.flatten (lib.mapAttrsToList
(groupName: grpCfg: lib.mapAttrsToList
(svcName: svcCfg: { inherit groupName svcName svcCfg; })
(lib.filterAttrs (_: svcCfg: svcCfg.dns.names != [ ]) grpCfg.services))
enabledGroups);
dnsServiceIp = s:
if s.svcCfg.dns.ip != null
then s.svcCfg.dns.ip
else
let ips = serviceStaticIps s.svcCfg;
in if lib.length ips == 1 then lib.head ips else null;
mkOverridesFileFor = groupName: grpCfg:
if grpCfg.composeFile != null
&& (grpCfg.networks != { } || grpCfg.volumes != { } || grpCfg.extraConfig != { })
@@ -53,7 +75,28 @@ in
message =
"skyg.nixos.common.container-services.${name}: set either composeFile OR services, not both.";
})
enabledGroups;
enabledGroups
++ map
(s: {
assertion = dnsServiceIp s != null;
message = ''
skyg.nixos.common.container-services.${s.groupName}.services.${s.svcName}:
dns.names is set but no address could be determined. Found
${toString (lib.length (serviceStaticIps s.svcCfg))} ipv4_address
entries in `networks` (exactly one is required). Set dns.ip
explicitly.
'';
})
dnsServices;
# Internal DNS records for services that asked for a name.
skyg.dns.records = map
(s: {
ip = dnsServiceIp s;
inherit (s.svcCfg.dns) names wildcard;
source = "container-services/${s.groupName}/${s.svcName}";
})
(lib.filter (s: dnsServiceIp s != null) dnsServices);
# Create tmpfiles rules for state dirs and file dirs
systemd.tmpfiles.rules =
@@ -166,6 +166,51 @@
'';
};
dns = lib.mkOption {
default = { };
description = ''
Internal DNS names for this service. Folded into
skyg.dns.records, aggregated across hosts at the flake level,
and pushed to the router by `skyg openwrt`. Nothing is
configured on the host itself.
'';
type = lib.types.submodule {
options = {
names = lib.mkOption {
type = lib.types.listOf lib.types.str;
default = [ ];
example = [ "drawdb" ];
description = ''
DNS names for this service. Bare labels (no dot) are
suffixed with skyg.dns.domain, so [ "drawdb" ] becomes
drawdb.app.internal.
'';
};
ip = lib.mkOption {
type = lib.types.nullOr lib.types.str;
default = null;
description = ''
Address the names resolve to. When null (the default)
it is derived from this service's `networks` block --
which requires exactly one ipv4_address to be present.
Set explicitly for host-networked services or when the
service is attached to several networks.
'';
};
wildcard = lib.mkOption {
type = lib.types.bool;
default = false;
description = ''
Also resolve every subdomain of these names
(dnsmasq `address=/name/ip` instead of `host-record=`).
'';
};
};
};
};
extra_hosts = lib.mkOption {
type = lib.types.listOf lib.types.str;
default = [ ];
@@ -215,6 +215,45 @@ group starts; groups only reference it (`external: true`) and never create it.
---
## Internal DNS names
A service with a static IP can declare its own internal DNS name. The record is folded into
`skyg.dns.records`, aggregated across every host at the flake level, and pushed to the
OpenWrt router's `dnsmasq.conf` by `skyg openwrt`. **Nothing is configured on the host.**
```nix
skyg.nixos.common.container-services.drawdb.services.drawdb = {
image = "ghcr.io/drawdb-io/drawdb:latest";
networks = { lan = { ipv4_address = "10.0.101.2"; }; };
dns.names = [ "drawdb" ]; # -> drawdb.app.internal
};
```
| Option | Default | Notes |
|---|---|---|
| `dns.names` | `[ ]` | Bare labels get `skyg.dns.domain` (default `app.internal`) appended; names containing a `.` are used as-is. |
| `dns.ip` | `null` | Derived from the service's `networks` block when it contains exactly one `ipv4_address`. Required for host-networked or multi-network services. |
| `dns.wildcard` | `false` | `true` also resolves every subdomain (`address=/name/ip` instead of `host-record=`). |
Setting `dns.names` without a derivable address is an **eval error** that names the offending
service. Two hosts mapping the same name to different IPs is also an eval error.
For IPs that aren't container services, use the host-level escape hatch instead:
```nix
skyg.dns.extraRecords.nas = { ip = "10.0.0.50"; names = [ "nas" "files" ]; };
```
Verify and deploy:
```sh
nix eval .#dnsRecords --json | jq # every record, all hosts
skyg openwrt --dry-run # render dnsmasq.conf locally
skyg openwrt # diff + confirm + apply
```
---
## Limitations
- **One unit per group.** No per-container systemd units. Use `docker compose logs` for
+1
View File
@@ -3,6 +3,7 @@
imports = [
./hardware
./containers
./dns-records
./core.nix
./networking.nix
./user.nix
@@ -0,0 +1,65 @@
# modules/nixos/common/dns-records/
Host-level registry of **internal DNS records**. This module configures *nothing* on the
host — it is a pure data collection point. Records declared here are aggregated across all
hosts at the flake level (`nix eval .#dnsRecords`) and pushed to the OpenWrt router's
`dnsmasq.conf` by `skyg openwrt` (see `modules/openwrt/`).
## Why
Service IPs live in host configs (e.g. a container's static macvlan address in
`hosts/hl-minipc2.nix`), but the router config lives in an encrypted JSON secret. Without a
bridge, naming a service means writing its IP in two places that silently drift. This module
is the single canonical shape everything writes to:
```nix
{ ip = "10.0.101.2"; names = [ "drawdb.app.internal" ]; wildcard = false; source = "..."; }
```
## Options
| Option | Purpose |
|---|---|
| `skyg.dns.domain` | Default suffix for bare names. Default `app.internal`. |
| `skyg.dns.extraRecords` | Hand-written records, keyed by name so they can be overridden. **Use this for arbitrary IPs.** |
| `skyg.dns.records` | List form. Modules append here (container-services does). |
| `skyg.dns.resolved` | Read-only: the above, names fully qualified + `host` attached. What the aggregator reads. |
| `skyg.dns.writeDebugFile` | Dump `resolved` to `/etc/skyg/dns-records.json`. Default true. |
Names without a `.` get `skyg.dns.domain` appended: `"drawdb"` → `"drawdb.app.internal"`.
Names containing a `.` are treated as fully-qualified and passed through untouched.
`wildcard = false` (the default) emits dnsmasq `host-record=name,ip` — a plain A record with
reverse PTR. `wildcard = true` emits `address=/name/ip`, which also catches every subdomain.
## Examples
Arbitrary IP, no container involved:
```nix
skyg.dns.extraRecords.nas = {
ip = "10.0.0.50";
names = [ "nas" "files" ]; # -> nas.app.internal, files.app.internal
};
```
From a container service (see `containers/container-services/`, which folds into `records`):
```nix
skyg.nixos.common.container-services.drawdb.services.drawdb = {
networks = { lan.ipv4_address = "10.0.101.2"; };
dns.names = [ "drawdb" ];
};
```
## Deploying
Records are inert until pushed to the router:
```sh
nix eval .#dnsRecords --json | jq # inspect the aggregate across all hosts
skyg openwrt --dry-run # render dnsmasq.conf locally
skyg openwrt # diff + confirm + apply on the router
```
Conflicts (the same name mapped to two different IPs, on any host) fail flake evaluation.
@@ -0,0 +1,132 @@
{ config, lib, ... }:
let
cfg = config.skyg.dns;
# Bare labels get the default domain appended; anything already containing a
# dot is treated as fully-qualified and left alone.
qualify = name:
if lib.hasInfix "." name || cfg.domain == null || cfg.domain == ""
then name
else "${name}.${cfg.domain}";
recordType = lib.types.submodule ({ ... }: {
options = {
ip = lib.mkOption {
type = lib.types.str;
example = "10.0.101.2";
description = "IPv4 address the names should resolve to.";
};
names = lib.mkOption {
type = lib.types.listOf lib.types.str;
example = [ "drawdb" "drawdb.app.internal" ];
description = ''
DNS names for this address. Bare labels (no dot) are automatically
suffixed with skyg.dns.domain.
'';
};
wildcard = lib.mkOption {
type = lib.types.bool;
default = false;
description = ''
When true, the record also matches every subdomain
(dnsmasq `address=/name/ip`). When false, a plain host record is
emitted (dnsmasq `host-record=name,ip`), which also provides reverse
PTR lookups.
'';
};
source = lib.mkOption {
type = lib.types.str;
default = "manual";
description = "Free-form provenance marker, used in generated comments.";
};
};
});
# Fully-qualified, host-tagged view of every record on this machine.
resolved = map
(r: {
inherit (r) ip wildcard source;
names = map qualify r.names;
host = config.networking.hostName;
})
(cfg.records ++ (lib.attrValues cfg.extraRecords));
in
{
options.skyg.dns = {
enable = lib.mkOption {
type = lib.types.bool;
default = true;
description = ''
Collect internal DNS records declared on this host. Records are pure
data -- they are aggregated at the flake level and pushed to the router
by `skyg openwrt`; nothing is configured on the host itself beyond a
debug dump in /etc/skyg/dns-records.json.
'';
};
domain = lib.mkOption {
type = lib.types.nullOr lib.types.str;
default = "app.internal";
example = "lab.internal";
description = "Default suffix appended to bare (dot-less) record names.";
};
records = lib.mkOption {
type = lib.types.listOf recordType;
default = [ ];
description = ''
Internal DNS records contributed by this host. Modules append to this
list (see container-services' `dns.names`); prefer `extraRecords` for
hand-written entries so they can be overridden by name.
'';
};
extraRecords = lib.mkOption {
type = lib.types.attrsOf recordType;
default = { };
example = lib.literalExpression ''
{
nas = { ip = "10.0.0.50"; names = [ "nas" "files" ]; };
}
'';
description = ''
Hand-written DNS records, keyed by an arbitrary name so they can be
overridden or removed from another module. Merged into `records`.
'';
};
resolved = lib.mkOption {
type = lib.types.listOf (lib.types.attrsOf lib.types.anything);
readOnly = true;
internal = true;
description = ''
Read-only: `records` + `extraRecords` with names fully qualified and the
owning hostname attached. This is what the flake-level aggregator reads.
'';
};
writeDebugFile = lib.mkOption {
type = lib.types.bool;
default = true;
description = "Write the resolved records to /etc/skyg/dns-records.json.";
};
};
config = lib.mkIf cfg.enable {
skyg.dns.resolved = resolved;
assertions = lib.flip map resolved (r: {
assertion = r.names != [ ];
message = "skyg.dns: record for ${r.ip} (source: ${r.source}) has no names.";
});
environment.etc."skyg/dns-records.json" = lib.mkIf (cfg.writeDebugFile && resolved != [ ]) {
text = builtins.toJSON resolved + "\n";
};
};
}
+7
View File
@@ -24,6 +24,12 @@ exported env vars before inlining each file's content via `builtins.readFile`.
## How it works
1. The router config lives as an **agenix secret** (e.g. `secrets/glmain.json.age`).
1b. Before generating, the decrypted JSON's `generalMappings` are **merged** (via `jq`) with
`$NIX_DNS_RECORDS` — the DNS records declared across all hosts through `skyg.dns`
(see `modules/nixos/common/dns-records/`) and aggregated by `modules/dns-aggregate.nix`
into `packages.<sys>.skyg-dns-records`. The secret stays the source of truth for
devices/MACs; **Nix owns service names**, so a container's DNS name lives next to the
host config that owns its IP. Inspect the aggregate with `nix eval .#dnsRecords --json`.
2. `openwrt-deploy` reads the decrypted JSON from stdin, runs `openwrt-gen dnsmasq`,
`openwrt-gen ethers`, and `openwrt-gen firewall` to render the three target files.
3. It SSHes to the router, shows a **colorized unified diff** against the current files
@@ -55,6 +61,7 @@ is passed as a command-line argument (default `glmain`).
```bash
skyg openwrt --dry-run
# → .tmp/openwrt-glmain/dnsmasq.conf
# → .tmp/openwrt-glmain/dns-records.json # the Nix-declared skyg.dns fragment merged in
# → .tmp/openwrt-glmain/ethers
# → .tmp/openwrt-glmain/firewall.batch # the exact `uci -m import firewall` input
```
+13
View File
@@ -17,6 +17,15 @@ in
config:
let
# Nix-generated DNS records (skyg.dns, aggregated across all hosts). Merged
# into the decrypted secret's generalMappings by the scripts below, so
# service names stay declarative next to the host config that owns the IP.
# Empty fragment when the caller doesn't supply one.
dnsRecords =
if config ? dnsRecords && config.dnsRecords != null
then config.dnsRecords
else builtins.toFile "skyg-dns-records-empty.json" (builtins.toJSON { generalMappings = [ ]; });
# Config JSON is read from stdin at deploy time — caller decrypts the age secret.
# Usage: age -d secrets/glmain.json.age | openwrt-deploy
#
@@ -24,10 +33,12 @@ let
# Nix-computed values it needs (router address, generator/apply-script store
# paths) and inlines the file's content after them.
deployScript = pkgs.writeShellScriptBin "openwrt-deploy" ''
export PATH="${lib.makeBinPath [ pkgs.jq ]}:$PATH"
export ROUTER="${config.router.ip}"
export ROUTER_USER="${config.router.user}"
export GENERATOR="${generator}"
export APPLY_SCRIPT="${applyScript}"
export NIX_DNS_RECORDS="${dnsRecords}"
${builtins.readFile ./openwrt-deploy.sh}
'';
@@ -35,7 +46,9 @@ let
# for review. No SSH, no uci, no router changes. Run from the repo root.
# The router name is passed as $1 (defaults to glmain) — see ./openwrt-dry-run.sh.
dryRunScript = pkgs.writeShellScriptBin "openwrt-dry-run" ''
export PATH="${lib.makeBinPath [ pkgs.jq ]}:$PATH"
export GENERATOR="${generator}"
export NIX_DNS_RECORDS="${dnsRecords}"
${builtins.readFile ./openwrt-dry-run.sh}
'';
in
+8 -1
View File
@@ -32,7 +32,14 @@ openwrt-gen firewall < config.json # prints UCI firewall rules (uci batch form
## Input shape (`config.rs`)
- `generalMappings`: `[{ ip, domains[] }]` — shared domain→IP records.
- `generalMappings`: `[{ ip, domains[], wildcard? }]` — shared domain→IP records.
`wildcard` defaults to `true` (omitted in existing secrets) and renders
`address=/domain/ip` + `address=/.domain/ip`, matching every subdomain too.
Set `false` for a plain `host-record=domain,ip` (A record + reverse PTR) —
this is what Nix-declared `skyg.dns` records use by default.
At deploy time this list is the **union** of the secret's entries and the
records aggregated from every host's `skyg.dns` (see
`modules/nixos/common/dns-records/`), merged by `jq` in `openwrt-deploy.sh`.
- `networks`: `{ <network>: [ { mac, name, id?, domains?, justMac?, internetOnly? } ] }` —
per-network hosts. A device with `internetOnly: true` is restricted to internet-only
access (matched by MAC), on any network.
+19
View File
@@ -17,6 +17,16 @@ pub struct Config {
pub struct GeneralMapping {
pub ip: String,
pub domains: Vec<String>,
/// When true (the default, kept for backwards compatibility with existing
/// router secrets), emit a wildcard `address=/domain/ip` that also matches
/// every subdomain. When false, emit a plain `host-record=domain,ip`,
/// which is a normal A record and also provides reverse PTR lookups.
#[serde(default = "default_true")]
pub wildcard: bool,
}
fn default_true() -> bool {
true
}
#[derive(Deserialize)]
@@ -77,6 +87,15 @@ mod tests {
let config: Config = serde_json::from_str(json).unwrap();
assert_eq!(config.general_mappings[0].ip, "192.168.1.1");
assert_eq!(config.general_mappings[0].domains, vec!["test.local"]);
// Existing secrets omit the flag; wildcard behaviour must be preserved.
assert!(config.general_mappings[0].wildcard);
}
#[test]
fn test_general_mapping_wildcard_false() {
let json = r#"{"generalMappings": [{"ip": "10.0.101.2", "domains": ["drawdb.app.internal"], "wildcard": false}], "networks": {}}"#;
let config: Config = serde_json::from_str(json).unwrap();
assert!(!config.general_mappings[0].wildcard);
}
#[test]
@@ -37,8 +37,13 @@ pub fn generate(config: &Config) -> String {
for gm in &config.general_mappings {
for domain in &gm.domains {
out.push_str(&format!("address=/{}/{}\n", domain, gm.ip));
out.push_str(&format!("address=/.{}/{}\n", domain, gm.ip));
if gm.wildcard {
out.push_str(&format!("address=/{}/{}\n", domain, gm.ip));
out.push_str(&format!("address=/.{}/{}\n", domain, gm.ip));
} else {
// Plain A record (+ reverse PTR), no subdomain wildcard.
out.push_str(&format!("host-record={},{}\n", domain, gm.ip));
}
}
}
@@ -78,6 +83,7 @@ mod tests {
general_mappings: vec![GeneralMapping {
ip: "192.168.1.1".to_string(),
domains: vec!["gw.local".to_string()],
wildcard: true,
}],
networks: BTreeMap::new(),
dns_resolvers: vec![],
@@ -85,6 +91,24 @@ mod tests {
};
let result = generate(&config);
assert!(result.contains("address=/gw.local/192.168.1.1\n"));
assert!(result.contains("address=/.gw.local/192.168.1.1\n"));
}
#[test]
fn test_general_mappings_host_record() {
let config = Config {
general_mappings: vec![GeneralMapping {
ip: "10.0.101.2".to_string(),
domains: vec!["drawdb.app.internal".to_string()],
wildcard: false,
}],
networks: BTreeMap::new(),
dns_resolvers: vec![],
internet_only: vec![],
};
let result = generate(&config);
assert!(result.contains("host-record=drawdb.app.internal,10.0.101.2\n"));
assert!(!result.contains("address=/"));
}
#[test]
+9 -1
View File
@@ -7,11 +7,19 @@
# ROUTER_USER - SSH user
# GENERATOR - store path of the openwrt-gen package (bin/openwrt-gen inside)
# APPLY_SCRIPT - store path of skyg-apply.sh
# NIX_DNS_RECORDS - store path of the Nix-generated generalMappings fragment
set -euo pipefail
SERVER="$ROUTER_USER@$ROUTER"
CONFIG=$(cat)
# Merge the Nix-declared DNS records (skyg.dns, aggregated across all hosts)
# into the secret's generalMappings. The secret stays the source of truth for
# devices/MACs; Nix owns service names.
CONFIG=$(cat | jq --slurpfile nix "$NIX_DNS_RECORDS" \
'.generalMappings = ((.generalMappings // []) + $nix[0].generalMappings)')
NIX_COUNT=$(jq '.generalMappings | length' "$NIX_DNS_RECORDS")
echo "Merged $NIX_COUNT Nix-declared DNS mapping(s) from skyg.dns."
DNSMASQ=$(echo "$CONFIG" | "$GENERATOR"/bin/openwrt-gen dnsmasq)
ETHERS=$(echo "$CONFIG" | "$GENERATOR"/bin/openwrt-gen ethers)
+9 -3
View File
@@ -3,14 +3,19 @@
# - no SSH, no uci, no router changes. Run from the repo root. Router name is
# passed as $1 (defaults to glmain).
#
# Expects GENERATOR to be exported by the Nix wrapper before this file's
# content runs (store path of the openwrt-gen package, bin/openwrt-gen inside).
# Expects GENERATOR and NIX_DNS_RECORDS to be exported by the Nix wrapper before
# this file's content runs (store paths of the openwrt-gen package and of the
# Nix-generated generalMappings fragment).
set -euo pipefail
if [ $# -ge 1 ]; then ROUTER="$1"; else ROUTER=glmain; fi
OUTDIR=".tmp/openwrt-$ROUTER"
mkdir -p "$OUTDIR"
CONFIG=$(cat)
# Same merge as the real deploy: secret config + Nix-declared skyg.dns records.
CONFIG=$(cat | jq --slurpfile nix "$NIX_DNS_RECORDS" \
'.generalMappings = ((.generalMappings // []) + $nix[0].generalMappings)')
cp "$NIX_DNS_RECORDS" "$OUTDIR/dns-records.json"
echo "$CONFIG" | "$GENERATOR"/bin/openwrt-gen dnsmasq > "$OUTDIR/dnsmasq.conf"
echo "$CONFIG" | "$GENERATOR"/bin/openwrt-gen ethers > "$OUTDIR/ethers"
@@ -20,3 +25,4 @@ echo "Dry-run configs written to $OUTDIR (no router changes made):"
echo " $OUTDIR/dnsmasq.conf"
echo " $OUTDIR/ethers"
echo " $OUTDIR/firewall.batch"
echo " $OUTDIR/dns-records.json # Nix-declared skyg.dns records merged in"