1801 lines
73 KiB
Nix
1801 lines
73 KiB
Nix
{ options, config, lib, pkgs, ... }:
|
|
|
|
with lib;
|
|
|
|
let
|
|
cfg = config.services.grafana;
|
|
opt = options.services.grafana;
|
|
provisioningSettingsFormat = pkgs.formats.yaml { };
|
|
declarativePlugins = pkgs.linkFarm "grafana-plugins" (builtins.map (pkg: { name = pkg.pname; path = pkg; }) cfg.declarativePlugins);
|
|
useMysql = cfg.settings.database.type == "mysql";
|
|
usePostgresql = cfg.settings.database.type == "postgres";
|
|
|
|
# Prefer using the values from the default config file[0] directly. This way,
|
|
# people reading the NixOS manual can see them without cross-referencing the
|
|
# official documentation.
|
|
#
|
|
# However, if there is no default entry or if the setting is optional, use
|
|
# `null` as the default value. It will be turned into the empty string.
|
|
#
|
|
# If a setting is a list, always allow setting it as a plain string as well.
|
|
#
|
|
# [0]: https://github.com/grafana/grafana/blob/main/conf/defaults.ini
|
|
settingsFormatIni = pkgs.formats.ini {
|
|
listToValue = concatMapStringsSep " " (generators.mkValueStringDefault { });
|
|
mkKeyValue = generators.mkKeyValueDefault
|
|
{
|
|
mkValueString = v:
|
|
if v == null then ""
|
|
else generators.mkValueStringDefault { } v;
|
|
}
|
|
"=";
|
|
};
|
|
configFile = settingsFormatIni.generate "config.ini" cfg.settings;
|
|
|
|
mkProvisionCfg = name: attr: provisionCfg:
|
|
if provisionCfg.path != null
|
|
then provisionCfg.path
|
|
else
|
|
provisioningSettingsFormat.generate "${name}.yaml"
|
|
(if provisionCfg.settings != null
|
|
then provisionCfg.settings
|
|
else {
|
|
apiVersion = 1;
|
|
${attr} = [ ];
|
|
});
|
|
|
|
datasourceFileOrDir = mkProvisionCfg "datasource" "datasources" cfg.provision.datasources;
|
|
dashboardFileOrDir = mkProvisionCfg "dashboard" "providers" cfg.provision.dashboards;
|
|
|
|
generateAlertingProvisioningYaml = x:
|
|
if (cfg.provision.alerting."${x}".path == null)
|
|
then provisioningSettingsFormat.generate "${x}.yaml" cfg.provision.alerting."${x}".settings
|
|
else cfg.provision.alerting."${x}".path;
|
|
rulesFileOrDir = generateAlertingProvisioningYaml "rules";
|
|
contactPointsFileOrDir = generateAlertingProvisioningYaml "contactPoints";
|
|
policiesFileOrDir = generateAlertingProvisioningYaml "policies";
|
|
templatesFileOrDir = generateAlertingProvisioningYaml "templates";
|
|
muteTimingsFileOrDir = generateAlertingProvisioningYaml "muteTimings";
|
|
|
|
ln = { src, dir, filename }: ''
|
|
if [[ -d "${src}" ]]; then
|
|
pushd $out/${dir} &>/dev/null
|
|
lndir "${src}"
|
|
popd &>/dev/null
|
|
else
|
|
ln -sf ${src} $out/${dir}/${filename}.yaml
|
|
fi
|
|
'';
|
|
provisionConfDir = pkgs.runCommand "grafana-provisioning" { nativeBuildInputs = [ pkgs.xorg.lndir ]; } ''
|
|
mkdir -p $out/{alerting,datasources,dashboards,plugins}
|
|
${ln { src = datasourceFileOrDir; dir = "datasources"; filename = "datasource"; }}
|
|
${ln { src = dashboardFileOrDir; dir = "dashboards"; filename = "dashboard"; }}
|
|
${ln { src = rulesFileOrDir; dir = "alerting"; filename = "rules"; }}
|
|
${ln { src = contactPointsFileOrDir; dir = "alerting"; filename = "contactPoints"; }}
|
|
${ln { src = policiesFileOrDir; dir = "alerting"; filename = "policies"; }}
|
|
${ln { src = templatesFileOrDir; dir = "alerting"; filename = "templates"; }}
|
|
${ln { src = muteTimingsFileOrDir; dir = "alerting"; filename = "muteTimings"; }}
|
|
'';
|
|
|
|
# Get a submodule without any embedded metadata:
|
|
_filter = x: filterAttrs (k: v: k != "_module") x;
|
|
|
|
# https://grafana.com/docs/grafana/latest/administration/provisioning/#datasources
|
|
grafanaTypes.datasourceConfig = types.submodule {
|
|
freeformType = provisioningSettingsFormat.type;
|
|
|
|
options = {
|
|
name = mkOption {
|
|
type = types.str;
|
|
description = "Name of the datasource. Required.";
|
|
};
|
|
type = mkOption {
|
|
type = types.str;
|
|
description = "Datasource type. Required.";
|
|
};
|
|
access = mkOption {
|
|
type = types.enum [ "proxy" "direct" ];
|
|
default = "proxy";
|
|
description = "Access mode. proxy or direct (Server or Browser in the UI). Required.";
|
|
};
|
|
uid = mkOption {
|
|
type = types.nullOr types.str;
|
|
default = null;
|
|
description = "Custom UID which can be used to reference this datasource in other parts of the configuration, if not specified will be generated automatically.";
|
|
};
|
|
url = mkOption {
|
|
type = types.str;
|
|
default = "";
|
|
description = "Url of the datasource.";
|
|
};
|
|
editable = mkOption {
|
|
type = types.bool;
|
|
default = false;
|
|
description = "Allow users to edit datasources from the UI.";
|
|
};
|
|
jsonData = mkOption {
|
|
type = types.nullOr types.attrs;
|
|
default = null;
|
|
description = "Extra data for datasource plugins.";
|
|
};
|
|
secureJsonData = mkOption {
|
|
type = types.nullOr types.attrs;
|
|
default = null;
|
|
description = ''
|
|
Datasource specific secure configuration. Please note that the contents of this option
|
|
will end up in a world-readable Nix store. Use the file provider
|
|
pointing at a reasonably secured file in the local filesystem
|
|
to work around that. Look at the documentation for details:
|
|
<https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/#file-provider>
|
|
'';
|
|
};
|
|
};
|
|
};
|
|
|
|
# https://grafana.com/docs/grafana/latest/administration/provisioning/#dashboards
|
|
grafanaTypes.dashboardConfig = types.submodule {
|
|
freeformType = provisioningSettingsFormat.type;
|
|
|
|
options = {
|
|
name = mkOption {
|
|
type = types.str;
|
|
default = "default";
|
|
description = "A unique provider name.";
|
|
};
|
|
type = mkOption {
|
|
type = types.str;
|
|
default = "file";
|
|
description = "Dashboard provider type.";
|
|
};
|
|
options.path = mkOption {
|
|
type = types.path;
|
|
description = "Path grafana will watch for dashboards. Required when using the 'file' type.";
|
|
};
|
|
};
|
|
};
|
|
in
|
|
{
|
|
imports = [
|
|
(mkRemovedOptionModule [ "services" "grafana" "provision" "notifiers" ] ''
|
|
Notifiers (services.grafana.provision.notifiers) were removed in Grafana 11.
|
|
'')
|
|
|
|
(mkRenamedOptionModule [ "services" "grafana" "protocol" ] [ "services" "grafana" "settings" "server" "protocol" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "addr" ] [ "services" "grafana" "settings" "server" "http_addr" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "port" ] [ "services" "grafana" "settings" "server" "http_port" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "domain" ] [ "services" "grafana" "settings" "server" "domain" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "rootUrl" ] [ "services" "grafana" "settings" "server" "root_url" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "staticRootPath" ] [ "services" "grafana" "settings" "server" "static_root_path" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "certFile" ] [ "services" "grafana" "settings" "server" "cert_file" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "certKey" ] [ "services" "grafana" "settings" "server" "cert_key" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "socket" ] [ "services" "grafana" "settings" "server" "socket" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "database" "type" ] [ "services" "grafana" "settings" "database" "type" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "database" "host" ] [ "services" "grafana" "settings" "database" "host" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "database" "name" ] [ "services" "grafana" "settings" "database" "name" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "database" "user" ] [ "services" "grafana" "settings" "database" "user" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "database" "password" ] [ "services" "grafana" "settings" "database" "password" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "database" "path" ] [ "services" "grafana" "settings" "database" "path" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "database" "connMaxLifetime" ] [ "services" "grafana" "settings" "database" "conn_max_lifetime" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "security" "adminUser" ] [ "services" "grafana" "settings" "security" "admin_user" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "security" "adminPassword" ] [ "services" "grafana" "settings" "security" "admin_password" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "security" "secretKey" ] [ "services" "grafana" "settings" "security" "secret_key" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "server" "serveFromSubPath" ] [ "services" "grafana" "settings" "server" "serve_from_sub_path" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "smtp" "enable" ] [ "services" "grafana" "settings" "smtp" "enabled" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "smtp" "user" ] [ "services" "grafana" "settings" "smtp" "user" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "smtp" "password" ] [ "services" "grafana" "settings" "smtp" "password" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "smtp" "fromAddress" ] [ "services" "grafana" "settings" "smtp" "from_address" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "users" "allowSignUp" ] [ "services" "grafana" "settings" "users" "allow_sign_up" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "users" "allowOrgCreate" ] [ "services" "grafana" "settings" "users" "allow_org_create" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "users" "autoAssignOrg" ] [ "services" "grafana" "settings" "users" "auto_assign_org" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "users" "autoAssignOrgRole" ] [ "services" "grafana" "settings" "users" "auto_assign_org_role" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "disableLoginForm" ] [ "services" "grafana" "settings" "auth" "disable_login_form" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "anonymous" "enable" ] [ "services" "grafana" "settings" "auth.anonymous" "enabled" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "anonymous" "org_name" ] [ "services" "grafana" "settings" "auth.anonymous" "org_name" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "anonymous" "org_role" ] [ "services" "grafana" "settings" "auth.anonymous" "org_role" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "azuread" "enable" ] [ "services" "grafana" "settings" "auth.azuread" "enabled" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "azuread" "allowSignUp" ] [ "services" "grafana" "settings" "auth.azuread" "allow_sign_up" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "azuread" "clientId" ] [ "services" "grafana" "settings" "auth.azuread" "client_id" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "azuread" "allowedDomains" ] [ "services" "grafana" "settings" "auth.azuread" "allowed_domains" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "azuread" "allowedGroups" ] [ "services" "grafana" "settings" "auth.azuread" "allowed_groups" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "google" "enable" ] [ "services" "grafana" "settings" "auth.google" "enabled" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "google" "allowSignUp" ] [ "services" "grafana" "settings" "auth.google" "allow_sign_up" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "auth" "google" "clientId" ] [ "services" "grafana" "settings" "auth.google" "client_id" ])
|
|
(mkRenamedOptionModule [ "services" "grafana" "analytics" "reporting" "enable" ] [ "services" "grafana" "settings" "analytics" "reporting_enabled" ])
|
|
|
|
(mkRemovedOptionModule [ "services" "grafana" "database" "passwordFile" ] ''
|
|
This option has been removed. Use 'services.grafana.settings.database.password' with file provider instead.
|
|
'')
|
|
(mkRemovedOptionModule [ "services" "grafana" "security" "adminPasswordFile" ] ''
|
|
This option has been removed. Use 'services.grafana.settings.security.admin_password' with file provider instead.
|
|
'')
|
|
(mkRemovedOptionModule [ "services" "grafana" "security" "secretKeyFile" ] ''
|
|
This option has been removed. Use 'services.grafana.settings.security.secret_key' with file provider instead.
|
|
'')
|
|
(mkRemovedOptionModule [ "services" "grafana" "smtp" "passwordFile" ] ''
|
|
This option has been removed. Use 'services.grafana.settings.smtp.password' with file provider instead.
|
|
'')
|
|
(mkRemovedOptionModule [ "services" "grafana" "auth" "azuread" "clientSecretFile" ] ''
|
|
This option has been removed. Use 'services.grafana.settings.azuread.client_secret' with file provider instead.
|
|
'')
|
|
(mkRemovedOptionModule [ "services" "grafana" "auth" "google" "clientSecretFile" ] ''
|
|
This option has been removed. Use 'services.grafana.settings.google.client_secret' with file provider instead.
|
|
'')
|
|
(mkRemovedOptionModule [ "services" "grafana" "extraOptions" ] ''
|
|
This option has been removed. Use 'services.grafana.settings' instead. For a detailed migration guide, please
|
|
review the release notes of NixOS 22.11.
|
|
'')
|
|
|
|
(mkRemovedOptionModule [ "services" "grafana" "auth" "azuread" "tenantId" ] "This option has been deprecated upstream.")
|
|
];
|
|
|
|
options.services.grafana = {
|
|
enable = mkEnableOption "grafana";
|
|
|
|
declarativePlugins = mkOption {
|
|
type = with types; nullOr (listOf path);
|
|
default = null;
|
|
description = "If non-null, then a list of packages containing Grafana plugins to install. If set, plugins cannot be manually installed.";
|
|
example = literalExpression "with pkgs.grafanaPlugins; [ grafana-piechart-panel ]";
|
|
# Make sure each plugin is added only once; otherwise building
|
|
# the link farm fails, since the same path is added multiple
|
|
# times.
|
|
apply = x: if isList x then lib.unique x else x;
|
|
};
|
|
|
|
package = mkPackageOption pkgs "grafana" { };
|
|
|
|
dataDir = mkOption {
|
|
description = "Data directory.";
|
|
default = "/var/lib/grafana";
|
|
type = types.path;
|
|
};
|
|
|
|
settings = mkOption {
|
|
description = ''
|
|
Grafana settings. See <https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/>
|
|
for available options. INI format is used.
|
|
'';
|
|
default = { };
|
|
type = types.submodule {
|
|
freeformType = settingsFormatIni.type;
|
|
|
|
options = {
|
|
paths = {
|
|
plugins = mkOption {
|
|
description = "Directory where grafana will automatically scan and look for plugins";
|
|
default = if (cfg.declarativePlugins == null) then "${cfg.dataDir}/plugins" else declarativePlugins;
|
|
defaultText = literalExpression "if (cfg.declarativePlugins == null) then \"\${cfg.dataDir}/plugins\" else declarativePlugins";
|
|
type = types.path;
|
|
};
|
|
|
|
provisioning = mkOption {
|
|
description = ''
|
|
Folder that contains provisioning config files that grafana will apply on startup and while running.
|
|
Don't change the value of this option if you are planning to use `services.grafana.provision` options.
|
|
'';
|
|
default = provisionConfDir;
|
|
defaultText = "directory with links to files generated from services.grafana.provision";
|
|
type = types.path;
|
|
};
|
|
};
|
|
|
|
server = {
|
|
protocol = mkOption {
|
|
description = "Which protocol to listen.";
|
|
default = "http";
|
|
type = types.enum [ "http" "https" "h2" "socket" ];
|
|
};
|
|
|
|
http_addr = mkOption {
|
|
type = types.str;
|
|
default = "127.0.0.1";
|
|
description = ''
|
|
Listening address.
|
|
|
|
::: {.note}
|
|
This setting intentionally varies from upstream's default to be a bit more secure by default.
|
|
:::
|
|
'';
|
|
};
|
|
|
|
http_port = mkOption {
|
|
description = "Listening port.";
|
|
default = 3000;
|
|
type = types.port;
|
|
};
|
|
|
|
domain = mkOption {
|
|
description = ''
|
|
The public facing domain name used to access grafana from a browser.
|
|
|
|
This setting is only used in the default value of the `root_url` setting.
|
|
If you set the latter manually, this option does not have to be specified.
|
|
'';
|
|
default = "localhost";
|
|
type = types.str;
|
|
};
|
|
|
|
enforce_domain = mkOption {
|
|
description = ''
|
|
Redirect to correct domain if the host header does not match the domain.
|
|
Prevents DNS rebinding attacks.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
root_url = mkOption {
|
|
description = ''
|
|
This is the full URL used to access Grafana from a web browser.
|
|
This is important if you use Google or GitHub OAuth authentication (for the callback URL to be correct).
|
|
|
|
This setting is also important if you have a reverse proxy in front of Grafana that exposes it through a subpath.
|
|
In that case add the subpath to the end of this URL setting.
|
|
'';
|
|
default = "%(protocol)s://%(domain)s:%(http_port)s/";
|
|
type = types.str;
|
|
};
|
|
|
|
serve_from_sub_path = mkOption {
|
|
description = ''
|
|
Serve Grafana from subpath specified in the `root_url` setting.
|
|
By default it is set to `false` for compatibility reasons.
|
|
|
|
By enabling this setting and using a subpath in `root_url` above,
|
|
e.g. `root_url = "http://localhost:3000/grafana"`,
|
|
Grafana is accessible on `http://localhost:3000/grafana`.
|
|
If accessed without subpath, Grafana will redirect to an URL with the subpath.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
router_logging = mkOption {
|
|
description = ''
|
|
Set to `true` for Grafana to log all HTTP requests (not just errors).
|
|
These are logged as Info level events to the Grafana log.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
static_root_path = mkOption {
|
|
description = "Root path for static assets.";
|
|
default = "${cfg.package}/share/grafana/public";
|
|
defaultText = literalExpression ''"''${package}/share/grafana/public"'';
|
|
type = types.str;
|
|
};
|
|
|
|
enable_gzip = mkOption {
|
|
description = ''
|
|
Set this option to `true` to enable HTTP compression, this can improve transfer speed and bandwidth utilization.
|
|
It is recommended that most users set it to `true`. By default it is set to `false` for compatibility reasons.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
cert_file = mkOption {
|
|
description = ''
|
|
Path to the certificate file (if `protocol` is set to `https` or `h2`).
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
cert_key = mkOption {
|
|
description = ''
|
|
Path to the certificate key file (if `protocol` is set to `https` or `h2`).
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
socket_gid = mkOption {
|
|
description = ''
|
|
GID where the socket should be set when `protocol=socket`.
|
|
Make sure that the target group is in the group of Grafana process and that Grafana process is the file owner before you change this setting.
|
|
It is recommended to set the gid as http server user gid.
|
|
Not set when the value is -1.
|
|
'';
|
|
default = -1;
|
|
type = types.int;
|
|
};
|
|
|
|
socket_mode = mkOption {
|
|
description = ''
|
|
Mode where the socket should be set when `protocol=socket`.
|
|
Make sure that Grafana process is the file owner before you change this setting.
|
|
'';
|
|
# I assume this value is interpreted as octal literal by grafana.
|
|
# If this was an int, people following tutorials or porting their
|
|
# old config could stumble across nix not having octal literals.
|
|
default = "0660";
|
|
type = types.str;
|
|
};
|
|
|
|
socket = mkOption {
|
|
description = ''
|
|
Path where the socket should be created when `protocol=socket`.
|
|
Make sure that Grafana has appropriate permissions before you change this setting.
|
|
'';
|
|
default = "/run/grafana/grafana.sock";
|
|
type = types.str;
|
|
};
|
|
|
|
cdn_url = mkOption {
|
|
description = ''
|
|
Specify a full HTTP URL address to the root of your Grafana CDN assets.
|
|
Grafana will add edition and version paths.
|
|
|
|
For example, given a cdn url like `https://cdn.myserver.com`
|
|
grafana will try to load a javascript file from `http://cdn.myserver.com/grafana-oss/7.4.0/public/build/app.<hash>.js`.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
read_timeout = mkOption {
|
|
description = ''
|
|
Sets the maximum time using a duration format (5s/5m/5ms)
|
|
before timing out read of an incoming request and closing idle connections.
|
|
0 means there is no timeout for reading the request.
|
|
'';
|
|
default = "0";
|
|
type = types.str;
|
|
};
|
|
};
|
|
|
|
database = {
|
|
type = mkOption {
|
|
description = "Database type.";
|
|
default = "sqlite3";
|
|
type = types.enum [ "mysql" "sqlite3" "postgres" ];
|
|
};
|
|
|
|
host = mkOption {
|
|
description = ''
|
|
Only applicable to MySQL or Postgres.
|
|
Includes IP or hostname and port or in case of Unix sockets the path to it.
|
|
For example, for MySQL running on the same host as Grafana: `host = "127.0.0.1:3306"`
|
|
or with Unix sockets: `host = "/var/run/mysqld/mysqld.sock"`
|
|
'';
|
|
default = "127.0.0.1:3306";
|
|
type = types.str;
|
|
};
|
|
|
|
name = mkOption {
|
|
description = "The name of the Grafana database.";
|
|
default = "grafana";
|
|
type = types.str;
|
|
};
|
|
|
|
user = mkOption {
|
|
description = "The database user (not applicable for `sqlite3`).";
|
|
default = "root";
|
|
type = types.str;
|
|
};
|
|
|
|
password = mkOption {
|
|
description = ''
|
|
The database user's password (not applicable for `sqlite3`).
|
|
|
|
Please note that the contents of this option
|
|
will end up in a world-readable Nix store. Use the file provider
|
|
pointing at a reasonably secured file in the local filesystem
|
|
to work around that. Look at the documentation for details:
|
|
<https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/#file-provider>
|
|
'';
|
|
default = "";
|
|
type = types.str;
|
|
};
|
|
|
|
max_idle_conn = mkOption {
|
|
description = "The maximum number of connections in the idle connection pool.";
|
|
default = 2;
|
|
type = types.int;
|
|
};
|
|
|
|
max_open_conn = mkOption {
|
|
description = "The maximum number of open connections to the database.";
|
|
default = 0;
|
|
type = types.int;
|
|
};
|
|
|
|
conn_max_lifetime = mkOption {
|
|
description = ''
|
|
Sets the maximum amount of time a connection may be reused.
|
|
The default is 14400 (which means 14400 seconds or 4 hours).
|
|
For MySQL, this setting should be shorter than the `wait_timeout` variable.
|
|
'';
|
|
default = 14400;
|
|
type = types.int;
|
|
};
|
|
|
|
locking_attempt_timeout_sec = mkOption {
|
|
description = ''
|
|
For `mysql`, if the `migrationLocking` feature toggle is set,
|
|
specify the time (in seconds) to wait before failing to lock the database for the migrations.
|
|
'';
|
|
default = 0;
|
|
type = types.int;
|
|
};
|
|
|
|
log_queries = mkOption {
|
|
description = "Set to `true` to log the sql calls and execution times";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
ssl_mode = mkOption {
|
|
description = ''
|
|
For Postgres, use either `disable`, `require` or `verify-full`.
|
|
For MySQL, use either `true`, `false`, or `skip-verify`.
|
|
'';
|
|
default = "disable";
|
|
type = types.enum [ "disable" "require" "verify-full" "true" "false" "skip-verify" ];
|
|
};
|
|
|
|
isolation_level = mkOption {
|
|
description = ''
|
|
Only the MySQL driver supports isolation levels in Grafana.
|
|
In case the value is empty, the driver's default isolation level is applied.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr (types.enum [ "READ-UNCOMMITTED" "READ-COMMITTED" "REPEATABLE-READ" "SERIALIZABLE" ]);
|
|
};
|
|
|
|
ca_cert_path = mkOption {
|
|
description = "The path to the CA certificate to use.";
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
client_key_path = mkOption {
|
|
description = "The path to the client key. Only if server requires client authentication.";
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
client_cert_path = mkOption {
|
|
description = "The path to the client cert. Only if server requires client authentication.";
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
server_cert_name = mkOption {
|
|
description = ''
|
|
The common name field of the certificate used by the `mysql` or `postgres` server.
|
|
Not necessary if `ssl_mode` is set to `skip-verify`.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
path = mkOption {
|
|
description = "Only applicable to `sqlite3` database. The file path where the database will be stored.";
|
|
default = "${cfg.dataDir}/data/grafana.db";
|
|
defaultText = literalExpression ''"''${config.${opt.dataDir}}/data/grafana.db"'';
|
|
type = types.path;
|
|
};
|
|
|
|
cache_mode = mkOption {
|
|
description = ''
|
|
For `sqlite3` only.
|
|
[Shared cache](https://www.sqlite.org/sharedcache.html) setting used for connecting to the database.
|
|
'';
|
|
default = "private";
|
|
type = types.enum [ "private" "shared" ];
|
|
};
|
|
|
|
wal = mkOption {
|
|
description = ''
|
|
For `sqlite3` only.
|
|
Setting to enable/disable [Write-Ahead Logging](https://sqlite.org/wal.html).
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
query_retries = mkOption {
|
|
description = ''
|
|
This setting applies to `sqlite3` only and controls the number of times the system retries a query when the database is locked.
|
|
'';
|
|
default = 0;
|
|
type = types.int;
|
|
};
|
|
|
|
transaction_retries = mkOption {
|
|
description = ''
|
|
This setting applies to `sqlite3` only and controls the number of times the system retries a transaction when the database is locked.
|
|
'';
|
|
default = 5;
|
|
type = types.int;
|
|
};
|
|
|
|
# TODO Add "instrument_queries" option when upgrading to grafana 10.0
|
|
# instrument_queries = mkOption {
|
|
# description = "Set to `true` to add metrics and tracing for database queries.";
|
|
# default = false;
|
|
# type = types.bool;
|
|
# };
|
|
};
|
|
|
|
security = {
|
|
disable_initial_admin_creation = mkOption {
|
|
description = "Disable creation of admin user on first start of Grafana.";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
admin_user = mkOption {
|
|
description = "Default admin username.";
|
|
default = "admin";
|
|
type = types.str;
|
|
};
|
|
|
|
admin_password = mkOption {
|
|
description = ''
|
|
Default admin password. Please note that the contents of this option
|
|
will end up in a world-readable Nix store. Use the file provider
|
|
pointing at a reasonably secured file in the local filesystem
|
|
to work around that. Look at the documentation for details:
|
|
<https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/#file-provider>
|
|
'';
|
|
default = "admin";
|
|
type = types.str;
|
|
};
|
|
|
|
admin_email = mkOption {
|
|
description = "The email of the default Grafana Admin, created on startup.";
|
|
default = "admin@localhost";
|
|
type = types.str;
|
|
};
|
|
|
|
secret_key = mkOption {
|
|
description = ''
|
|
Secret key used for signing. Please note that the contents of this option
|
|
will end up in a world-readable Nix store. Use the file provider
|
|
pointing at a reasonably secured file in the local filesystem
|
|
to work around that. Look at the documentation for details:
|
|
<https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/#file-provider>
|
|
'';
|
|
default = "SW2YcwTIb9zpOOhoPsMm";
|
|
type = types.str;
|
|
};
|
|
|
|
disable_gravatar = mkOption {
|
|
description = "Set to `true` to disable the use of Gravatar for user profile images.";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
data_source_proxy_whitelist = mkOption {
|
|
description = ''
|
|
Define a whitelist of allowed IP addresses or domains, with ports,
|
|
to be used in data source URLs with the Grafana data source proxy.
|
|
Format: `ip_or_domain:port` separated by spaces.
|
|
PostgreSQL, MySQL, and MSSQL data sources do not use the proxy and are therefore unaffected by this setting.
|
|
'';
|
|
default = [ ];
|
|
type = types.oneOf [ types.str (types.listOf types.str) ];
|
|
};
|
|
|
|
disable_brute_force_login_protection = mkOption {
|
|
description = "Set to `true` to disable [brute force login protection](https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html#account-lockout).";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
cookie_secure = mkOption {
|
|
description = "Set to `true` if you host Grafana behind HTTPS.";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
cookie_samesite = mkOption {
|
|
description = ''
|
|
Sets the `SameSite` cookie attribute and prevents the browser from sending this cookie along with cross-site requests.
|
|
The main goal is to mitigate the risk of cross-origin information leakage.
|
|
This setting also provides some protection against cross-site request forgery attacks (CSRF),
|
|
[read more about SameSite here](https://owasp.org/www-community/SameSite).
|
|
Using value `disabled` does not add any `SameSite` attribute to cookies.
|
|
'';
|
|
default = "lax";
|
|
type = types.enum [ "lax" "strict" "none" "disabled" ];
|
|
};
|
|
|
|
allow_embedding = mkOption {
|
|
description = ''
|
|
When `false`, the HTTP header `X-Frame-Options: deny` will be set in Grafana HTTP responses
|
|
which will instruct browsers to not allow rendering Grafana in a `<frame>`, `<iframe>`, `<embed>` or `<object>`.
|
|
The main goal is to mitigate the risk of [Clickjacking](https://owasp.org/www-community/attacks/Clickjacking).
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
strict_transport_security = mkOption {
|
|
description = ''
|
|
Set to `true` if you want to enable HTTP `Strict-Transport-Security` (HSTS) response header.
|
|
Only use this when HTTPS is enabled in your configuration,
|
|
or when there is another upstream system that ensures your application does HTTPS (like a frontend load balancer).
|
|
HSTS tells browsers that the site should only be accessed using HTTPS.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
strict_transport_security_max_age_seconds = mkOption {
|
|
description = ''
|
|
Sets how long a browser should cache HSTS in seconds.
|
|
Only applied if `strict_transport_security` is enabled.
|
|
'';
|
|
default = 86400;
|
|
type = types.int;
|
|
};
|
|
|
|
strict_transport_security_preload = mkOption {
|
|
description = ''
|
|
Set to `true` to enable HSTS `preloading` option.
|
|
Only applied if `strict_transport_security` is enabled.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
strict_transport_security_subdomains = mkOption {
|
|
description = ''
|
|
Set to `true` to enable HSTS `includeSubDomains` option.
|
|
Only applied if `strict_transport_security` is enabled.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
x_content_type_options = mkOption {
|
|
description = ''
|
|
Set to `false` to disable the `X-Content-Type-Options` response header.
|
|
The `X-Content-Type-Options` response HTTP header is a marker used by the server
|
|
to indicate that the MIME types advertised in the `Content-Type` headers should not be changed and be followed.
|
|
'';
|
|
default = true;
|
|
type = types.bool;
|
|
};
|
|
|
|
x_xss_protection = mkOption {
|
|
description = ''
|
|
Set to `false` to disable the `X-XSS-Protection` header,
|
|
which tells browsers to stop pages from loading when they detect reflected cross-site scripting (XSS) attacks.
|
|
'';
|
|
default = true;
|
|
type = types.bool;
|
|
};
|
|
|
|
content_security_policy = mkOption {
|
|
description = ''
|
|
Set to `true` to add the `Content-Security-Policy` header to your requests.
|
|
CSP allows to control resources that the user agent can load and helps prevent XSS attacks.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
content_security_policy_report_only = mkOption {
|
|
description = ''
|
|
Set to `true` to add the `Content-Security-Policy-Report-Only` header to your requests.
|
|
CSP in Report Only mode enables you to experiment with policies by monitoring their effects without enforcing them.
|
|
You can enable both policies simultaneously.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
# The options content_security_policy_template and
|
|
# content_security_policy_template are missing because I'm not sure
|
|
# how exactly the quoting of the default value works. See also
|
|
# https://github.com/grafana/grafana/blob/cb7e18938b8eb6860a64b91aaba13a7eb31bc95b/conf/defaults.ini#L364
|
|
# https://github.com/grafana/grafana/blob/cb7e18938b8eb6860a64b91aaba13a7eb31bc95b/conf/defaults.ini#L373
|
|
|
|
# These two options are lists joined with spaces:
|
|
# https://github.com/grafana/grafana/blob/916d9793aa81c2990640b55a15dee0db6b525e41/pkg/middleware/csrf/csrf.go#L37-L38
|
|
|
|
csrf_trusted_origins = mkOption {
|
|
description = ''
|
|
List of additional allowed URLs to pass by the CSRF check.
|
|
Suggested when authentication comes from an IdP.
|
|
'';
|
|
default = [ ];
|
|
type = types.oneOf [ types.str (types.listOf types.str) ];
|
|
};
|
|
|
|
csrf_additional_headers = mkOption {
|
|
description = ''
|
|
List of allowed headers to be set by the user.
|
|
Suggested to use for if authentication lives behind reverse proxies.
|
|
'';
|
|
default = [ ];
|
|
type = types.oneOf [ types.str (types.listOf types.str) ];
|
|
};
|
|
};
|
|
|
|
smtp = {
|
|
enabled = mkOption {
|
|
description = "Whether to enable SMTP.";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
host = mkOption {
|
|
description = "Host to connect to.";
|
|
default = "localhost:25";
|
|
type = types.str;
|
|
};
|
|
|
|
user = mkOption {
|
|
description = "User used for authentication.";
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
password = mkOption {
|
|
description = ''
|
|
Password used for authentication. Please note that the contents of this option
|
|
will end up in a world-readable Nix store. Use the file provider
|
|
pointing at a reasonably secured file in the local filesystem
|
|
to work around that. Look at the documentation for details:
|
|
<https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/#file-provider>
|
|
'';
|
|
default = "";
|
|
type = types.str;
|
|
};
|
|
|
|
cert_file = mkOption {
|
|
description = "File path to a cert file.";
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
key_file = mkOption {
|
|
description = "File path to a key file.";
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
skip_verify = mkOption {
|
|
description = "Verify SSL for SMTP server.";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
from_address = mkOption {
|
|
description = "Address used when sending out emails.";
|
|
default = "admin@grafana.localhost";
|
|
type = types.str;
|
|
};
|
|
|
|
from_name = mkOption {
|
|
description = "Name to be used as client identity for EHLO in SMTP dialog.";
|
|
default = "Grafana";
|
|
type = types.str;
|
|
};
|
|
|
|
ehlo_identity = mkOption {
|
|
description = "Name to be used as client identity for EHLO in SMTP dialog.";
|
|
default = null;
|
|
type = types.nullOr types.str;
|
|
};
|
|
|
|
startTLS_policy = mkOption {
|
|
description = "StartTLS policy when connecting to server.";
|
|
default = null;
|
|
type = types.nullOr (types.enum [ "OpportunisticStartTLS" "MandatoryStartTLS" "NoStartTLS" ]);
|
|
};
|
|
};
|
|
|
|
users = {
|
|
allow_sign_up = mkOption {
|
|
description = ''
|
|
Set to false to prohibit users from being able to sign up / create user accounts.
|
|
The admin user can still create users.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
allow_org_create = mkOption {
|
|
description = "Set to `false` to prohibit users from creating new organizations.";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
auto_assign_org = mkOption {
|
|
description = ''
|
|
Set to `true` to automatically add new users to the main organization (id 1).
|
|
When set to `false,` new users automatically cause a new organization to be created for that new user.
|
|
The organization will be created even if the `allow_org_create` setting is set to `false`.
|
|
'';
|
|
default = true;
|
|
type = types.bool;
|
|
};
|
|
|
|
auto_assign_org_id = mkOption {
|
|
description = ''
|
|
Set this value to automatically add new users to the provided org.
|
|
This requires `auto_assign_org` to be set to `true`.
|
|
Please make sure that this organization already exists.
|
|
'';
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
auto_assign_org_role = mkOption {
|
|
description = ''
|
|
The role new users will be assigned for the main organization (if the `auto_assign_org` setting is set to `true`).
|
|
'';
|
|
default = "Viewer";
|
|
type = types.enum [ "Viewer" "Editor" "Admin" ];
|
|
};
|
|
|
|
verify_email_enabled = mkOption {
|
|
description = "Require email validation before sign up completes.";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
login_hint = mkOption {
|
|
description = "Text used as placeholder text on login page for login/username input.";
|
|
default = "email or username";
|
|
type = types.str;
|
|
};
|
|
|
|
password_hint = mkOption {
|
|
description = "Text used as placeholder text on login page for password input.";
|
|
default = "password";
|
|
type = types.str;
|
|
};
|
|
|
|
default_theme = mkOption {
|
|
description = "Sets the default UI theme. `system` matches the user's system theme.";
|
|
default = "dark";
|
|
type = types.enum [ "dark" "light" "system" ];
|
|
};
|
|
|
|
default_language = mkOption {
|
|
description = "This setting configures the default UI language, which must be a supported IETF language tag, such as `en-US`.";
|
|
default = "en-US";
|
|
type = types.str;
|
|
};
|
|
|
|
home_page = mkOption {
|
|
description = ''
|
|
Path to a custom home page.
|
|
Users are only redirected to this if the default home dashboard is used.
|
|
It should match a frontend route and contain a leading slash.
|
|
'';
|
|
default = "";
|
|
type = types.str;
|
|
};
|
|
|
|
viewers_can_edit = mkOption {
|
|
description = ''
|
|
Viewers can access and use Explore and perform temporary edits on panels in dashboards they have access to.
|
|
They cannot save their changes.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
editors_can_admin = mkOption {
|
|
description = "Editors can administrate dashboards, folders and teams they create.";
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
user_invite_max_lifetime_duration = mkOption {
|
|
description = ''
|
|
The duration in time a user invitation remains valid before expiring.
|
|
This setting should be expressed as a duration.
|
|
Examples: `6h` (hours), `2d` (days), `1w` (week).
|
|
The minimum supported duration is `15m` (15 minutes).
|
|
'';
|
|
default = "24h";
|
|
type = types.str;
|
|
};
|
|
|
|
# Lists are joined via space, so this option can't be a list.
|
|
# Users have to manually join their values.
|
|
hidden_users = mkOption {
|
|
description = ''
|
|
This is a comma-separated list of usernames.
|
|
Users specified here are hidden in the Grafana UI.
|
|
They are still visible to Grafana administrators and to themselves.
|
|
'';
|
|
default = "";
|
|
type = types.str;
|
|
};
|
|
};
|
|
|
|
analytics = {
|
|
reporting_enabled = mkOption {
|
|
description = ''
|
|
When enabled Grafana will send anonymous usage statistics to `stats.grafana.org`.
|
|
No IP addresses are being tracked, only simple counters to track running instances, versions, dashboard and error counts.
|
|
Counters are sent every 24 hours.
|
|
'';
|
|
default = true;
|
|
type = types.bool;
|
|
};
|
|
|
|
check_for_updates = mkOption {
|
|
description = ''
|
|
When set to `false`, disables checking for new versions of Grafana from Grafana's GitHub repository.
|
|
When enabled, the check for a new version runs every 10 minutes.
|
|
It will notify, via the UI, when a new version is available.
|
|
The check itself will not prompt any auto-updates of the Grafana software, nor will it send any sensitive information.
|
|
'';
|
|
default = false;
|
|
type = types.bool;
|
|
};
|
|
|
|
check_for_plugin_updates = mkOption {
|
|
description = ''
|
|
When set to `false`, disables checking for new versions of installed plugins from https://grafana.com.
|
|
When enabled, the check for a new plugin runs every 10 minutes.
|
|
It will notify, via the UI, when a new plugin update exists.
|
|
The check itself will not prompt any auto-updates of the plugin, nor will it send any sensitive information.
|
|
'';
|
|
default = cfg.declarativePlugins == null;
|
|
defaultText = literalExpression "cfg.declarativePlugins == null";
|
|
type = types.bool;
|
|
};
|
|
|
|
feedback_links_enabled = mkOption {
|
|
description = "Set to `false` to remove all feedback links from the UI.";
|
|
default = true;
|
|
type = types.bool;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
provision = {
|
|
enable = mkEnableOption "provision";
|
|
|
|
datasources = mkOption {
|
|
description = ''
|
|
Declaratively provision Grafana's datasources.
|
|
'';
|
|
default = { };
|
|
type = types.submodule {
|
|
options.settings = mkOption {
|
|
description = ''
|
|
Grafana datasource configuration in Nix. Can't be used with
|
|
[](#opt-services.grafana.provision.datasources.path) simultaneously. See
|
|
<https://grafana.com/docs/grafana/latest/administration/provisioning/#data-sources>
|
|
for supported options.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr (types.submodule {
|
|
options = {
|
|
apiVersion = mkOption {
|
|
description = "Config file version.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
datasources = mkOption {
|
|
description = "List of datasources to insert/update.";
|
|
default = [ ];
|
|
type = types.listOf grafanaTypes.datasourceConfig;
|
|
};
|
|
|
|
deleteDatasources = mkOption {
|
|
description = "List of datasources that should be deleted from the database.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
options.name = mkOption {
|
|
description = "Name of the datasource to delete.";
|
|
type = types.str;
|
|
};
|
|
|
|
options.orgId = mkOption {
|
|
description = "Organization ID of the datasource to delete.";
|
|
type = types.int;
|
|
};
|
|
});
|
|
};
|
|
};
|
|
});
|
|
example = literalExpression ''
|
|
{
|
|
apiVersion = 1;
|
|
|
|
datasources = [{
|
|
name = "Graphite";
|
|
type = "graphite";
|
|
}];
|
|
|
|
deleteDatasources = [{
|
|
name = "Graphite";
|
|
orgId = 1;
|
|
}];
|
|
}
|
|
'';
|
|
};
|
|
|
|
options.path = mkOption {
|
|
description = ''
|
|
Path to YAML datasource configuration. Can't be used with
|
|
[](#opt-services.grafana.provision.datasources.settings) simultaneously.
|
|
Can be either a directory or a single YAML file. Will end up in the store.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.path;
|
|
};
|
|
};
|
|
};
|
|
|
|
|
|
dashboards = mkOption {
|
|
description = ''
|
|
Declaratively provision Grafana's dashboards.
|
|
'';
|
|
default = { };
|
|
type = types.submodule {
|
|
options.settings = mkOption {
|
|
description = ''
|
|
Grafana dashboard configuration in Nix. Can't be used with
|
|
[](#opt-services.grafana.provision.dashboards.path) simultaneously. See
|
|
<https://grafana.com/docs/grafana/latest/administration/provisioning/#dashboards>
|
|
for supported options.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr (types.submodule {
|
|
options.apiVersion = mkOption {
|
|
description = "Config file version.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
options.providers = mkOption {
|
|
description = "List of dashboards to insert/update.";
|
|
default = [ ];
|
|
type = types.listOf grafanaTypes.dashboardConfig;
|
|
};
|
|
});
|
|
example = literalExpression ''
|
|
{
|
|
apiVersion = 1;
|
|
|
|
providers = [{
|
|
name = "default";
|
|
options.path = "/var/lib/grafana/dashboards";
|
|
}];
|
|
}
|
|
'';
|
|
};
|
|
|
|
options.path = mkOption {
|
|
description = ''
|
|
Path to YAML dashboard configuration. Can't be used with
|
|
[](#opt-services.grafana.provision.dashboards.settings) simultaneously.
|
|
Can be either a directory or a single YAML file. Will end up in the store.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.path;
|
|
};
|
|
};
|
|
};
|
|
|
|
alerting = {
|
|
rules = {
|
|
path = mkOption {
|
|
description = ''
|
|
Path to YAML rules configuration. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.rules.settings) simultaneously.
|
|
Can be either a directory or a single YAML file. Will end up in the store.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.path;
|
|
};
|
|
|
|
settings = mkOption {
|
|
description = ''
|
|
Grafana rules configuration in Nix. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.rules.path) simultaneously. See
|
|
<https://grafana.com/docs/grafana/latest/administration/provisioning/#rules>
|
|
for supported options.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr (types.submodule {
|
|
options = {
|
|
apiVersion = mkOption {
|
|
description = "Config file version.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
groups = mkOption {
|
|
description = "List of rule groups to import or update.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
freeformType = provisioningSettingsFormat.type;
|
|
|
|
options.name = mkOption {
|
|
description = "Name of the rule group. Required.";
|
|
type = types.str;
|
|
};
|
|
|
|
options.folder = mkOption {
|
|
description = "Name of the folder the rule group will be stored in. Required.";
|
|
type = types.str;
|
|
};
|
|
|
|
options.interval = mkOption {
|
|
description = "Interval that the rule group should be evaluated at. Required.";
|
|
type = types.str;
|
|
};
|
|
});
|
|
};
|
|
|
|
deleteRules = mkOption {
|
|
description = "List of alert rule UIDs that should be deleted.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
options.orgId = mkOption {
|
|
description = "Organization ID, default = 1";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
options.uid = mkOption {
|
|
description = "Unique identifier for the rule. Required.";
|
|
type = types.str;
|
|
};
|
|
});
|
|
};
|
|
};
|
|
});
|
|
example = literalExpression ''
|
|
{
|
|
apiVersion = 1;
|
|
|
|
groups = [{
|
|
orgId = 1;
|
|
name = "my_rule_group";
|
|
folder = "my_first_folder";
|
|
interval = "60s";
|
|
rules = [{
|
|
uid = "my_id_1";
|
|
title = "my_first_rule";
|
|
condition = "A";
|
|
data = [{
|
|
refId = "A";
|
|
datasourceUid = "-100";
|
|
model = {
|
|
conditions = [{
|
|
evaluator = {
|
|
params = [ 3 ];
|
|
type = "git";
|
|
};
|
|
operator.type = "and";
|
|
query.params = [ "A" ];
|
|
reducer.type = "last";
|
|
type = "query";
|
|
}];
|
|
datasource = {
|
|
type = "__expr__";
|
|
uid = "-100";
|
|
};
|
|
expression = "1==0";
|
|
intervalMs = 1000;
|
|
maxDataPoints = 43200;
|
|
refId = "A";
|
|
type = "math";
|
|
};
|
|
}];
|
|
dashboardUid = "my_dashboard";
|
|
panelId = 123;
|
|
noDataState = "Alerting";
|
|
for = "60s";
|
|
annotations.some_key = "some_value";
|
|
labels.team = "sre_team1";
|
|
}];
|
|
}];
|
|
|
|
deleteRules = [{
|
|
orgId = 1;
|
|
uid = "my_id_1";
|
|
}];
|
|
}
|
|
'';
|
|
};
|
|
};
|
|
|
|
contactPoints = {
|
|
path = mkOption {
|
|
description = ''
|
|
Path to YAML contact points configuration. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.contactPoints.settings) simultaneously.
|
|
Can be either a directory or a single YAML file. Will end up in the store.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.path;
|
|
};
|
|
|
|
settings = mkOption {
|
|
description = ''
|
|
Grafana contact points configuration in Nix. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.contactPoints.path) simultaneously. See
|
|
<https://grafana.com/docs/grafana/latest/administration/provisioning/#contact-points>
|
|
for supported options.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr (types.submodule {
|
|
options = {
|
|
apiVersion = mkOption {
|
|
description = "Config file version.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
contactPoints = mkOption {
|
|
description = "List of contact points to import or update.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
freeformType = provisioningSettingsFormat.type;
|
|
|
|
options.name = mkOption {
|
|
description = "Name of the contact point. Required.";
|
|
type = types.str;
|
|
};
|
|
});
|
|
};
|
|
|
|
deleteContactPoints = mkOption {
|
|
description = "List of receivers that should be deleted.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
options.orgId = mkOption {
|
|
description = "Organization ID, default = 1.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
options.uid = mkOption {
|
|
description = "Unique identifier for the receiver. Required.";
|
|
type = types.str;
|
|
};
|
|
});
|
|
};
|
|
};
|
|
});
|
|
example = literalExpression ''
|
|
{
|
|
apiVersion = 1;
|
|
|
|
contactPoints = [{
|
|
orgId = 1;
|
|
name = "cp_1";
|
|
receivers = [{
|
|
uid = "first_uid";
|
|
type = "prometheus-alertmanager";
|
|
settings.url = "http://test:9000";
|
|
}];
|
|
}];
|
|
|
|
deleteContactPoints = [{
|
|
orgId = 1;
|
|
uid = "first_uid";
|
|
}];
|
|
}
|
|
'';
|
|
};
|
|
};
|
|
|
|
policies = {
|
|
path = mkOption {
|
|
description = ''
|
|
Path to YAML notification policies configuration. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.policies.settings) simultaneously.
|
|
Can be either a directory or a single YAML file. Will end up in the store.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.path;
|
|
};
|
|
|
|
settings = mkOption {
|
|
description = ''
|
|
Grafana notification policies configuration in Nix. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.policies.path) simultaneously. See
|
|
<https://grafana.com/docs/grafana/latest/administration/provisioning/#notification-policies>
|
|
for supported options.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr (types.submodule {
|
|
options = {
|
|
apiVersion = mkOption {
|
|
description = "Config file version.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
policies = mkOption {
|
|
description = "List of contact points to import or update.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
freeformType = provisioningSettingsFormat.type;
|
|
});
|
|
};
|
|
|
|
resetPolicies = mkOption {
|
|
description = "List of orgIds that should be reset to the default policy.";
|
|
default = [ ];
|
|
type = types.listOf types.int;
|
|
};
|
|
};
|
|
});
|
|
example = literalExpression ''
|
|
{
|
|
apiVersion = 1;
|
|
|
|
policies = [{
|
|
orgId = 1;
|
|
receiver = "grafana-default-email";
|
|
group_by = [ "..." ];
|
|
matchers = [
|
|
"alertname = Watchdog"
|
|
"severity =~ \"warning|critical\""
|
|
];
|
|
mute_time_intervals = [
|
|
"abc"
|
|
];
|
|
group_wait = "30s";
|
|
group_interval = "5m";
|
|
repeat_interval = "4h";
|
|
}];
|
|
|
|
resetPolicies = [
|
|
1
|
|
];
|
|
}
|
|
'';
|
|
};
|
|
};
|
|
|
|
templates = {
|
|
path = mkOption {
|
|
description = ''
|
|
Path to YAML templates configuration. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.templates.settings) simultaneously.
|
|
Can be either a directory or a single YAML file. Will end up in the store.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.path;
|
|
};
|
|
|
|
settings = mkOption {
|
|
description = ''
|
|
Grafana templates configuration in Nix. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.templates.path) simultaneously. See
|
|
<https://grafana.com/docs/grafana/latest/administration/provisioning/#templates>
|
|
for supported options.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr (types.submodule {
|
|
options = {
|
|
apiVersion = mkOption {
|
|
description = "Config file version.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
templates = mkOption {
|
|
description = "List of templates to import or update.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
freeformType = provisioningSettingsFormat.type;
|
|
|
|
options.name = mkOption {
|
|
description = "Name of the template, must be unique. Required.";
|
|
type = types.str;
|
|
};
|
|
|
|
options.template = mkOption {
|
|
description = "Alerting with a custom text template";
|
|
type = types.str;
|
|
};
|
|
});
|
|
};
|
|
|
|
deleteTemplates = mkOption {
|
|
description = "List of alert rule UIDs that should be deleted.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
options.orgId = mkOption {
|
|
description = "Organization ID, default = 1.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
options.name = mkOption {
|
|
description = "Name of the template, must be unique. Required.";
|
|
type = types.str;
|
|
};
|
|
});
|
|
};
|
|
};
|
|
});
|
|
example = literalExpression ''
|
|
{
|
|
apiVersion = 1;
|
|
|
|
templates = [{
|
|
orgId = 1;
|
|
name = "my_first_template";
|
|
template = "Alerting with a custom text template";
|
|
}];
|
|
|
|
deleteTemplates = [{
|
|
orgId = 1;
|
|
name = "my_first_template";
|
|
}];
|
|
}
|
|
'';
|
|
};
|
|
};
|
|
|
|
muteTimings = {
|
|
path = mkOption {
|
|
description = ''
|
|
Path to YAML mute timings configuration. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.muteTimings.settings) simultaneously.
|
|
Can be either a directory or a single YAML file. Will end up in the store.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr types.path;
|
|
};
|
|
|
|
settings = mkOption {
|
|
description = ''
|
|
Grafana mute timings configuration in Nix. Can't be used with
|
|
[](#opt-services.grafana.provision.alerting.muteTimings.path) simultaneously. See
|
|
<https://grafana.com/docs/grafana/latest/administration/provisioning/#mute-timings>
|
|
for supported options.
|
|
'';
|
|
default = null;
|
|
type = types.nullOr (types.submodule {
|
|
options = {
|
|
apiVersion = mkOption {
|
|
description = "Config file version.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
muteTimes = mkOption {
|
|
description = "List of mute time intervals to import or update.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
freeformType = provisioningSettingsFormat.type;
|
|
|
|
options.name = mkOption {
|
|
description = "Name of the mute time interval, must be unique. Required.";
|
|
type = types.str;
|
|
};
|
|
});
|
|
};
|
|
|
|
deleteMuteTimes = mkOption {
|
|
description = "List of mute time intervals that should be deleted.";
|
|
default = [ ];
|
|
type = types.listOf (types.submodule {
|
|
options.orgId = mkOption {
|
|
description = "Organization ID, default = 1.";
|
|
default = 1;
|
|
type = types.int;
|
|
};
|
|
|
|
options.name = mkOption {
|
|
description = "Name of the mute time interval, must be unique. Required.";
|
|
type = types.str;
|
|
};
|
|
});
|
|
};
|
|
};
|
|
});
|
|
example = literalExpression ''
|
|
{
|
|
apiVersion = 1;
|
|
|
|
muteTimes = [{
|
|
orgId = 1;
|
|
name = "mti_1";
|
|
time_intervals = [{
|
|
times = [{
|
|
start_time = "06:00";
|
|
end_time = "23:59";
|
|
}];
|
|
weekdays = [
|
|
"monday:wednesday"
|
|
"saturday"
|
|
"sunday"
|
|
];
|
|
months = [
|
|
"1:3"
|
|
"may:august"
|
|
"december"
|
|
];
|
|
years = [
|
|
"2020:2022"
|
|
"2030"
|
|
];
|
|
days_of_month = [
|
|
"1:5"
|
|
"-3:-1"
|
|
];
|
|
}];
|
|
}];
|
|
|
|
deleteMuteTimes = [{
|
|
orgId = 1;
|
|
name = "mti_1";
|
|
}];
|
|
}
|
|
'';
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
config = mkIf cfg.enable {
|
|
warnings =
|
|
let
|
|
doesntUseFileProvider = opt: defaultValue:
|
|
let regex = "${optionalString (defaultValue != null) "^${defaultValue}$|"}^\\$__(file|env)\\{.*}$|^\\$[^_\\$][^ ]+$";
|
|
in builtins.match regex opt == null;
|
|
|
|
# Ensure that no custom credentials are leaked into the Nix store. Unless the default value
|
|
# is specified, this can be achieved by using the file/env provider:
|
|
# https://grafana.com/docs/grafana/latest/setup-grafana/configure-grafana/#variable-expansion
|
|
passwordWithoutFileProvider = optional
|
|
(
|
|
doesntUseFileProvider cfg.settings.database.password "" ||
|
|
doesntUseFileProvider cfg.settings.security.admin_password "admin"
|
|
)
|
|
''
|
|
Grafana passwords will be stored as plaintext in the Nix store!
|
|
Use file provider or an env-var instead.
|
|
'';
|
|
|
|
# Ensure that `secureJsonData` of datasources provisioned via `datasources.settings`
|
|
# only uses file/env providers.
|
|
secureJsonDataWithoutFileProvider = optional
|
|
(
|
|
let
|
|
datasourcesToCheck = optionals
|
|
(cfg.provision.datasources.settings != null)
|
|
cfg.provision.datasources.settings.datasources;
|
|
declarationUnsafe = { secureJsonData, ... }:
|
|
secureJsonData != null
|
|
&& any (flip doesntUseFileProvider null) (attrValues secureJsonData);
|
|
in
|
|
any declarationUnsafe datasourcesToCheck
|
|
)
|
|
''
|
|
Declarations in the `secureJsonData`-block of a datasource will be leaked to the
|
|
Nix store unless a file-provider or an env-var is used!
|
|
'';
|
|
in
|
|
passwordWithoutFileProvider
|
|
++ secureJsonDataWithoutFileProvider
|
|
;
|
|
|
|
environment.systemPackages = [ cfg.package ];
|
|
|
|
assertions = [
|
|
{
|
|
assertion = cfg.provision.datasources.settings == null || cfg.provision.datasources.path == null;
|
|
message = "Cannot set both datasources settings and datasources path";
|
|
}
|
|
{
|
|
assertion =
|
|
let
|
|
prometheusIsNotDirect = opt: all
|
|
({ type, access, ... }: type == "prometheus" -> access != "direct")
|
|
opt;
|
|
in
|
|
cfg.provision.datasources.settings == null || prometheusIsNotDirect cfg.provision.datasources.settings.datasources;
|
|
message = "For datasources of type `prometheus`, the `direct` access mode is not supported anymore (since Grafana 9.2.0)";
|
|
}
|
|
{
|
|
assertion = cfg.provision.dashboards.settings == null || cfg.provision.dashboards.path == null;
|
|
message = "Cannot set both dashboards settings and dashboards path";
|
|
}
|
|
{
|
|
assertion = cfg.provision.alerting.rules.settings == null || cfg.provision.alerting.rules.path == null;
|
|
message = "Cannot set both rules settings and rules path";
|
|
}
|
|
{
|
|
assertion = cfg.provision.alerting.contactPoints.settings == null || cfg.provision.alerting.contactPoints.path == null;
|
|
message = "Cannot set both contact points settings and contact points path";
|
|
}
|
|
{
|
|
assertion = cfg.provision.alerting.policies.settings == null || cfg.provision.alerting.policies.path == null;
|
|
message = "Cannot set both policies settings and policies path";
|
|
}
|
|
{
|
|
assertion = cfg.provision.alerting.templates.settings == null || cfg.provision.alerting.templates.path == null;
|
|
message = "Cannot set both templates settings and templates path";
|
|
}
|
|
{
|
|
assertion = cfg.provision.alerting.muteTimings.settings == null || cfg.provision.alerting.muteTimings.path == null;
|
|
message = "Cannot set both mute timings settings and mute timings path";
|
|
}
|
|
];
|
|
|
|
systemd.services.grafana = {
|
|
description = "Grafana Service Daemon";
|
|
wantedBy = [ "multi-user.target" ];
|
|
after = [ "networking.target" ] ++ lib.optional usePostgresql "postgresql.service" ++ lib.optional useMysql "mysql.service";
|
|
script = ''
|
|
set -o errexit -o pipefail -o nounset -o errtrace
|
|
shopt -s inherit_errexit
|
|
|
|
exec ${cfg.package}/bin/grafana server -homepath ${cfg.dataDir} -config ${configFile}
|
|
'';
|
|
serviceConfig = {
|
|
WorkingDirectory = cfg.dataDir;
|
|
User = "grafana";
|
|
Restart = "on-failure";
|
|
RuntimeDirectory = "grafana";
|
|
RuntimeDirectoryMode = "0755";
|
|
# Hardening
|
|
AmbientCapabilities = lib.mkIf (cfg.settings.server.http_port < 1024) [ "CAP_NET_BIND_SERVICE" ];
|
|
CapabilityBoundingSet = if (cfg.settings.server.http_port < 1024) then [ "CAP_NET_BIND_SERVICE" ] else [ "" ];
|
|
DeviceAllow = [ "" ];
|
|
LockPersonality = true;
|
|
NoNewPrivileges = true;
|
|
PrivateDevices = true;
|
|
PrivateTmp = true;
|
|
ProtectClock = true;
|
|
ProtectControlGroups = true;
|
|
ProtectHome = true;
|
|
ProtectHostname = true;
|
|
ProtectKernelLogs = true;
|
|
ProtectKernelModules = true;
|
|
ProtectKernelTunables = true;
|
|
ProtectProc = "invisible";
|
|
ProtectSystem = "full";
|
|
RemoveIPC = true;
|
|
RestrictAddressFamilies = [ "AF_INET" "AF_INET6" "AF_UNIX" ];
|
|
RestrictNamespaces = true;
|
|
RestrictRealtime = true;
|
|
RestrictSUIDSGID = true;
|
|
SystemCallArchitectures = "native";
|
|
# Upstream grafana is not setting SystemCallFilter for compatibility
|
|
# reasons, see https://github.com/grafana/grafana/pull/40176
|
|
SystemCallFilter = [
|
|
"@system-service"
|
|
"~@privileged"
|
|
] ++ lib.optionals (cfg.settings.server.protocol == "socket") [ "@chown" ];
|
|
UMask = "0027";
|
|
};
|
|
preStart = ''
|
|
ln -fs ${cfg.package}/share/grafana/conf ${cfg.dataDir}
|
|
ln -fs ${cfg.package}/share/grafana/tools ${cfg.dataDir}
|
|
'';
|
|
};
|
|
|
|
users.users.grafana = {
|
|
uid = config.ids.uids.grafana;
|
|
description = "Grafana user";
|
|
home = cfg.dataDir;
|
|
createHome = true;
|
|
group = "grafana";
|
|
};
|
|
users.groups.grafana = { };
|
|
};
|
|
}
|