941c79b620
This commit fixes two bugs: 1) When starting a github-runner for the very first time, the unconfigure script did not copy the `tokenFile` to the state directory. This case just was not handled so far. As a result, the runner could not configure. The unit did, however, fail even before as the state token file is configured as inaccessible for the service through `InaccessiblePaths=`. As the given path did not exist in the described case, setting up the unit's namespacing failed. 2) Similarly, the `tokenFile` is also marked as not accessible to the service user. There are, however, cases where other namespacing options make the files inaccessible even before `InaccessiblePaths=` kicks in; thus, they appear as non existing and cause the namespacing to fail yet again. Prefixing the entry with a `-` causes Systemd to ignore the entry if it cannot find it. This is the behavior we want. I also took fixing those bugs as a chance to refactor the unconfigure script to make it easier to follow.
397 lines
15 KiB
Nix
397 lines
15 KiB
Nix
{ config, pkgs, lib, ... }:
|
|
with lib;
|
|
let
|
|
cfg = config.services.github-runner;
|
|
svcName = "github-runner";
|
|
systemdDir = "${svcName}/${cfg.name}";
|
|
# %t: Runtime directory root (usually /run); see systemd.unit(5)
|
|
runtimeDir = "%t/${systemdDir}";
|
|
# %S: State directory root (usually /var/lib); see systemd.unit(5)
|
|
stateDir = "%S/${systemdDir}";
|
|
# %L: Log directory root (usually /var/log); see systemd.unit(5)
|
|
logsDir = "%L/${systemdDir}";
|
|
# Name of file stored in service state directory
|
|
currentConfigTokenFilename = ".current-token";
|
|
in
|
|
{
|
|
options.services.github-runner = {
|
|
enable = mkOption {
|
|
default = false;
|
|
example = true;
|
|
description = lib.mdDoc ''
|
|
Whether to enable GitHub Actions runner.
|
|
|
|
Note: GitHub recommends using self-hosted runners with private repositories only. Learn more here:
|
|
[About self-hosted runners](https://docs.github.com/en/actions/hosting-your-own-runners/about-self-hosted-runners).
|
|
'';
|
|
type = lib.types.bool;
|
|
};
|
|
|
|
url = mkOption {
|
|
type = types.str;
|
|
description = lib.mdDoc ''
|
|
Repository to add the runner to.
|
|
|
|
Changing this option triggers a new runner registration.
|
|
|
|
IMPORTANT: If your token is org-wide (not per repository), you need to
|
|
provide a github org link, not a single repository, so do it like this
|
|
`https://github.com/nixos`, not like this
|
|
`https://github.com/nixos/nixpkgs`.
|
|
Otherwise, you are going to get a `404 NotFound`
|
|
from `POST https://api.github.com/actions/runner-registration`
|
|
in the configure script.
|
|
'';
|
|
example = "https://github.com/nixos/nixpkgs";
|
|
};
|
|
|
|
tokenFile = mkOption {
|
|
type = types.path;
|
|
description = lib.mdDoc ''
|
|
The full path to a file which contains either a runner registration token or a
|
|
personal access token (PAT).
|
|
The file should contain exactly one line with the token without any newline.
|
|
If a registration token is given, it can be used to re-register a runner of the same
|
|
name but is time-limited. If the file contains a PAT, the service creates a new
|
|
registration token on startup as needed. Make sure the PAT has a scope of
|
|
`admin:org` for organization-wide registrations or a scope of
|
|
`repo` for a single repository.
|
|
|
|
Changing this option or the file's content triggers a new runner registration.
|
|
'';
|
|
example = "/run/secrets/github-runner/nixos.token";
|
|
};
|
|
|
|
name = mkOption {
|
|
# Same pattern as for `networking.hostName`
|
|
type = types.strMatching "^$|^[[:alnum:]]([[:alnum:]_-]{0,61}[[:alnum:]])?$";
|
|
description = lib.mdDoc ''
|
|
Name of the runner to configure. Defaults to the hostname.
|
|
|
|
Changing this option triggers a new runner registration.
|
|
'';
|
|
example = "nixos";
|
|
default = config.networking.hostName;
|
|
defaultText = literalExpression "config.networking.hostName";
|
|
};
|
|
|
|
runnerGroup = mkOption {
|
|
type = types.nullOr types.str;
|
|
description = lib.mdDoc ''
|
|
Name of the runner group to add this runner to (defaults to the default runner group).
|
|
|
|
Changing this option triggers a new runner registration.
|
|
'';
|
|
default = null;
|
|
};
|
|
|
|
extraLabels = mkOption {
|
|
type = types.listOf types.str;
|
|
description = lib.mdDoc ''
|
|
Extra labels in addition to the default (`["self-hosted", "Linux", "X64"]`).
|
|
|
|
Changing this option triggers a new runner registration.
|
|
'';
|
|
example = literalExpression ''[ "nixos" ]'';
|
|
default = [ ];
|
|
};
|
|
|
|
replace = mkOption {
|
|
type = types.bool;
|
|
description = lib.mdDoc ''
|
|
Replace any existing runner with the same name.
|
|
|
|
Without this flag, registering a new runner with the same name fails.
|
|
'';
|
|
default = false;
|
|
};
|
|
|
|
extraPackages = mkOption {
|
|
type = types.listOf types.package;
|
|
description = lib.mdDoc ''
|
|
Extra packages to add to `PATH` of the service to make them available to workflows.
|
|
'';
|
|
default = [ ];
|
|
};
|
|
|
|
package = mkOption {
|
|
type = types.package;
|
|
description = lib.mdDoc ''
|
|
Which github-runner derivation to use.
|
|
'';
|
|
default = pkgs.github-runner;
|
|
defaultText = literalExpression "pkgs.github-runner";
|
|
};
|
|
|
|
ephemeral = mkOption {
|
|
type = types.bool;
|
|
description = lib.mdDoc ''
|
|
If enabled, causes the following behavior:
|
|
|
|
- Passes the `--ephemeral` flag to the runner configuration script
|
|
- De-registers and stops the runner with GitHub after it has processed one job
|
|
- On stop, systemd wipes the runtime directory (this always happens, even without using the ephemeral option)
|
|
- Restarts the service after its successful exit
|
|
- On start, wipes the state directory and configures a new runner
|
|
|
|
You should only enable this option if `tokenFile` points to a file which contains a
|
|
personal access token (PAT). If you're using the option with a registration token, restarting the
|
|
service will fail as soon as the registration token expired.
|
|
'';
|
|
default = false;
|
|
};
|
|
};
|
|
|
|
config = mkIf cfg.enable {
|
|
warnings = optionals (isStorePath cfg.tokenFile) [
|
|
''
|
|
`services.github-runner.tokenFile` points to the Nix store and, therefore, is world-readable.
|
|
Consider using a path outside of the Nix store to keep the token private.
|
|
''
|
|
];
|
|
|
|
systemd.services.${svcName} = {
|
|
description = "GitHub Actions runner";
|
|
|
|
wantedBy = [ "multi-user.target" ];
|
|
wants = [ "network-online.target" ];
|
|
after = [ "network.target" "network-online.target" ];
|
|
|
|
environment = {
|
|
HOME = runtimeDir;
|
|
RUNNER_ROOT = stateDir;
|
|
};
|
|
|
|
path = (with pkgs; [
|
|
bash
|
|
coreutils
|
|
git
|
|
gnutar
|
|
gzip
|
|
]) ++ [
|
|
config.nix.package
|
|
] ++ cfg.extraPackages;
|
|
|
|
serviceConfig = rec {
|
|
ExecStart = "${cfg.package}/bin/Runner.Listener run --startuptype service";
|
|
|
|
# Does the following, sequentially:
|
|
# - If the module configuration or the token has changed, purge the state directory,
|
|
# and create the current and the new token file with the contents of the configured
|
|
# token. While both files have the same content, only the later is accessible by
|
|
# the service user.
|
|
# - Configure the runner using the new token file. When finished, delete it.
|
|
# - Set up the directory structure by creating the necessary symlinks.
|
|
ExecStartPre =
|
|
let
|
|
# Wrapper script which expects the full path of the state, runtime and logs
|
|
# directory as arguments. Overrides the respective systemd variables to provide
|
|
# unambiguous directory names. This becomes relevant, for example, if the
|
|
# caller overrides any of the StateDirectory=, RuntimeDirectory= or LogDirectory=
|
|
# to contain more than one directory. This causes systemd to set the respective
|
|
# environment variables with the path of all of the given directories, separated
|
|
# by a colon.
|
|
writeScript = name: lines: pkgs.writeShellScript "${svcName}-${name}.sh" ''
|
|
set -euo pipefail
|
|
|
|
STATE_DIRECTORY="$1"
|
|
RUNTIME_DIRECTORY="$2"
|
|
LOGS_DIRECTORY="$3"
|
|
|
|
${lines}
|
|
'';
|
|
runnerRegistrationConfig = getAttrs [ "name" "tokenFile" "url" "runnerGroup" "extraLabels" "ephemeral" ] cfg;
|
|
newConfigPath = builtins.toFile "${svcName}-config.json" (builtins.toJSON runnerRegistrationConfig);
|
|
currentConfigPath = "$STATE_DIRECTORY/.nixos-current-config.json";
|
|
newConfigTokenPath= "$STATE_DIRECTORY/.new-token";
|
|
currentConfigTokenPath = "$STATE_DIRECTORY/${currentConfigTokenFilename}";
|
|
|
|
runnerCredFiles = [
|
|
".credentials"
|
|
".credentials_rsaparams"
|
|
".runner"
|
|
];
|
|
unconfigureRunner = writeScript "unconfigure" ''
|
|
copy_tokens() {
|
|
# Copy the configured token file to the state dir and allow the service user to read the file
|
|
install --mode=666 ${escapeShellArg cfg.tokenFile} "${newConfigTokenPath}"
|
|
# Also copy current file to allow for a diff on the next start
|
|
install --mode=600 ${escapeShellArg cfg.tokenFile} "${currentConfigTokenPath}"
|
|
}
|
|
|
|
clean_state() {
|
|
find "$STATE_DIRECTORY/" -mindepth 1 -delete
|
|
copy_tokens
|
|
}
|
|
|
|
diff_config() {
|
|
changed=0
|
|
|
|
# Check for module config changes
|
|
[[ -f "${currentConfigPath}" ]] \
|
|
&& ${pkgs.diffutils}/bin/diff -q '${newConfigPath}' "${currentConfigPath}" >/dev/null 2>&1 \
|
|
|| changed=1
|
|
|
|
# Also check the content of the token file
|
|
[[ -f "${currentConfigTokenPath}" ]] \
|
|
&& ${pkgs.diffutils}/bin/diff -q "${currentConfigTokenPath}" ${escapeShellArg cfg.tokenFile} >/dev/null 2>&1 \
|
|
|| changed=1
|
|
|
|
# If the config has changed, remove old state and copy tokens
|
|
if [[ "$changed" -eq 1 ]]; then
|
|
echo "Config has changed, removing old runner state."
|
|
echo "The old runner will still appear in the GitHub Actions UI." \
|
|
"You have to remove it manually."
|
|
clean_state
|
|
fi
|
|
}
|
|
|
|
if [[ "${optionalString cfg.ephemeral "1"}" ]]; then
|
|
# In ephemeral mode, we always want to start with a clean state
|
|
clean_state
|
|
elif [[ "$(ls -A "$STATE_DIRECTORY")" ]]; then
|
|
# There are state files from a previous run; diff them to decide if we need a new registration
|
|
diff_config
|
|
else
|
|
# The state directory is entirely empty which indicates a first start
|
|
copy_tokens
|
|
fi
|
|
'';
|
|
configureRunner = writeScript "configure" ''
|
|
if [[ -e "${newConfigTokenPath}" ]]; then
|
|
echo "Configuring GitHub Actions Runner"
|
|
|
|
args=(
|
|
--unattended
|
|
--disableupdate
|
|
--work "$RUNTIME_DIRECTORY"
|
|
--url ${escapeShellArg cfg.url}
|
|
--labels ${escapeShellArg (concatStringsSep "," cfg.extraLabels)}
|
|
--name ${escapeShellArg cfg.name}
|
|
${optionalString cfg.replace "--replace"}
|
|
${optionalString (cfg.runnerGroup != null) "--runnergroup ${escapeShellArg cfg.runnerGroup}"}
|
|
${optionalString cfg.ephemeral "--ephemeral"}
|
|
)
|
|
|
|
# If the token file contains a PAT (i.e., it starts with "ghp_"), we have to use the --pat option,
|
|
# if it is not a PAT, we assume it contains a registration token and use the --token option
|
|
token=$(<"${newConfigTokenPath}")
|
|
if [[ "$token" =~ ^ghp_* ]]; then
|
|
args+=(--pat "$token")
|
|
else
|
|
args+=(--token "$token")
|
|
fi
|
|
|
|
${cfg.package}/bin/config.sh "''${args[@]}"
|
|
|
|
# Move the automatically created _diag dir to the logs dir
|
|
mkdir -p "$STATE_DIRECTORY/_diag"
|
|
cp -r "$STATE_DIRECTORY/_diag/." "$LOGS_DIRECTORY/"
|
|
rm -rf "$STATE_DIRECTORY/_diag/"
|
|
|
|
# Cleanup token from config
|
|
rm "${newConfigTokenPath}"
|
|
|
|
# Symlink to new config
|
|
ln -s '${newConfigPath}' "${currentConfigPath}"
|
|
fi
|
|
'';
|
|
setupRuntimeDir = writeScript "setup-runtime-dirs" ''
|
|
# Link _diag dir
|
|
ln -s "$LOGS_DIRECTORY" "$RUNTIME_DIRECTORY/_diag"
|
|
|
|
# Link the runner credentials to the runtime dir
|
|
ln -s "$STATE_DIRECTORY"/{${lib.concatStringsSep "," runnerCredFiles}} "$RUNTIME_DIRECTORY/"
|
|
'';
|
|
in
|
|
map (x: "${x} ${escapeShellArgs [ stateDir runtimeDir logsDir ]}") [
|
|
"+${unconfigureRunner}" # runs as root
|
|
configureRunner
|
|
setupRuntimeDir
|
|
];
|
|
|
|
# If running in ephemeral mode, restart the service on-exit (i.e., successful de-registration of the runner)
|
|
# to trigger a fresh registration.
|
|
Restart = if cfg.ephemeral then "on-success" else "no";
|
|
|
|
# Contains _diag
|
|
LogsDirectory = [ systemdDir ];
|
|
# Default RUNNER_ROOT which contains ephemeral Runner data
|
|
RuntimeDirectory = [ systemdDir ];
|
|
# Home of persistent runner data, e.g., credentials
|
|
StateDirectory = [ systemdDir ];
|
|
StateDirectoryMode = "0700";
|
|
WorkingDirectory = runtimeDir;
|
|
|
|
InaccessiblePaths = [
|
|
# Token file path given in the configuration, if visible to the service
|
|
"-${cfg.tokenFile}"
|
|
# Token file in the state directory
|
|
"${stateDir}/${currentConfigTokenFilename}"
|
|
];
|
|
|
|
# By default, use a dynamically allocated user
|
|
DynamicUser = true;
|
|
|
|
KillSignal = "SIGINT";
|
|
|
|
# Hardening (may overlap with DynamicUser=)
|
|
# The following options are only for optimizing:
|
|
# systemd-analyze security github-runner
|
|
AmbientCapabilities = "";
|
|
CapabilityBoundingSet = "";
|
|
# ProtectClock= adds DeviceAllow=char-rtc r
|
|
DeviceAllow = "";
|
|
NoNewPrivileges = true;
|
|
PrivateDevices = true;
|
|
PrivateMounts = true;
|
|
PrivateTmp = true;
|
|
PrivateUsers = true;
|
|
ProtectClock = true;
|
|
ProtectControlGroups = true;
|
|
ProtectHome = true;
|
|
ProtectHostname = true;
|
|
ProtectKernelLogs = true;
|
|
ProtectKernelModules = true;
|
|
ProtectKernelTunables = true;
|
|
ProtectSystem = "strict";
|
|
RemoveIPC = true;
|
|
RestrictNamespaces = true;
|
|
RestrictRealtime = true;
|
|
RestrictSUIDSGID = true;
|
|
UMask = "0066";
|
|
ProtectProc = "invisible";
|
|
SystemCallFilter = [
|
|
"~@clock"
|
|
"~@cpu-emulation"
|
|
"~@module"
|
|
"~@mount"
|
|
"~@obsolete"
|
|
"~@raw-io"
|
|
"~@reboot"
|
|
"~capset"
|
|
"~setdomainname"
|
|
"~sethostname"
|
|
];
|
|
RestrictAddressFamilies = [ "AF_INET" "AF_INET6" "AF_UNIX" "AF_NETLINK" ];
|
|
|
|
# Needs network access
|
|
PrivateNetwork = false;
|
|
# Cannot be true due to Node
|
|
MemoryDenyWriteExecute = false;
|
|
|
|
# The more restrictive "pid" option makes `nix` commands in CI emit
|
|
# "GC Warning: Couldn't read /proc/stat"
|
|
# You may want to set this to "pid" if not using `nix` commands
|
|
ProcSubset = "all";
|
|
# Coverage programs for compiled code such as `cargo-tarpaulin` disable
|
|
# ASLR (address space layout randomization) which requires the
|
|
# `personality` syscall
|
|
# You may want to set this to `true` if not using coverage tooling on
|
|
# compiled code
|
|
LockPersonality = false;
|
|
};
|
|
};
|
|
};
|
|
}
|