diff --git a/.gitattributes b/.gitattributes index 3b14a98b3..5279db5d3 100644 --- a/.gitattributes +++ b/.gitattributes @@ -2,3 +2,4 @@ hscontrol/policy/v2/testdata/*_results/** linguist-generated hscontrol/servertest/testdata/steps/** linguist-generated hscontrol/testdata/apiv1_golden/** linguist-generated +hscontrol/types/testdata/compat/*.golden.json linguist-generated diff --git a/.prettierignore b/.prettierignore index 5b01a8737..5560a2fbd 100644 --- a/.prettierignore +++ b/.prettierignore @@ -3,3 +3,4 @@ docs/ # Golden fixtures are byte-compared; a formatter must not rewrite them. hscontrol/testdata/ +hscontrol/types/testdata/compat/ diff --git a/hscontrol/types/testdata/compat/bad-policy-mode.yaml b/hscontrol/types/testdata/compat/bad-policy-mode.yaml new file mode 100644 index 000000000..784cc7fcb --- /dev/null +++ b/hscontrol/types/testdata/compat/bad-policy-mode.yaml @@ -0,0 +1,15 @@ +# An unknown policy.mode loads today and runs with no policy. +server_url: https://hs.example.com +noise: + private_key_path: /var/lib/headscale/noise.key +prefixes: + v4: 100.64.0.0/10 +database: + type: sqlite + sqlite: + path: /var/lib/headscale/db.sqlite +dns: + magic_dns: false + override_local_dns: false +policy: + mode: databse diff --git a/hscontrol/types/testdata/compat/bad-values.yaml b/hscontrol/types/testdata/compat/bad-values.yaml new file mode 100644 index 000000000..8a1636003 --- /dev/null +++ b/hscontrol/types/testdata/compat/bad-values.yaml @@ -0,0 +1,23 @@ +# Input today's loader accepts but mangles or ignores. +server_url: https://hs.example.com +noise: + private_key_path: /var/lib/headscale/noise.key +prefixes: + v4: 10.0.0.0/8 +database: + type: sqlite + sqlite: + path: /var/lib/headscale/db.sqlite +dns: + magic_dns: false + magic_dsn: true + override_local_dns: false +log: + level: verbose + format: xml +tuning: + notifier_send_timeout: abc +derp: + urls: + - "://not-a-url" +ephemeral_node_inactivity_timeout: 30m diff --git a/hscontrol/types/testdata/compat/env-cli.env b/hscontrol/types/testdata/compat/env-cli.env new file mode 100644 index 000000000..0a3d538fb --- /dev/null +++ b/hscontrol/types/testdata/compat/env-cli.env @@ -0,0 +1,4 @@ +HEADSCALE_CLI_ADDRESS=headscale.example.com:443 +HEADSCALE_CLI_API_KEY=marker-cli-api-key +HEADSCALE_CLI_TIMEOUT=10s +HEADSCALE_CLI_INSECURE=1 diff --git a/hscontrol/types/testdata/compat/env-empty.env b/hscontrol/types/testdata/compat/env-empty.env new file mode 100644 index 000000000..c971d686e --- /dev/null +++ b/hscontrol/types/testdata/compat/env-empty.env @@ -0,0 +1,5 @@ +HEADSCALE_POLICY_PATH= +HEADSCALE_DERP_URLS= +HEADSCALE_LOG_LEVEL= +HEADSCALE_DNS_MAGIC_DNS= +HEADSCALE_TAILDROP_ENABLED= diff --git a/hscontrol/types/testdata/compat/env-empty.yaml b/hscontrol/types/testdata/compat/env-empty.yaml new file mode 100644 index 000000000..5ef55d5cb --- /dev/null +++ b/hscontrol/types/testdata/compat/env-empty.yaml @@ -0,0 +1,19 @@ +server_url: https://hs.example.com +noise: + private_key_path: /var/lib/headscale/noise.key +prefixes: + v4: 100.64.0.0/10 +database: + type: sqlite + sqlite: + path: /var/lib/headscale/db.sqlite +dns: + magic_dns: false + override_local_dns: false +log: + level: debug +policy: + path: /etc/headscale/policy.hujson +derp: + urls: + - https://controlplane.tailscale.com/derpmap/default diff --git a/hscontrol/types/testdata/compat/env-extra-records.env b/hscontrol/types/testdata/compat/env-extra-records.env new file mode 100644 index 000000000..3f5d975dc --- /dev/null +++ b/hscontrol/types/testdata/compat/env-extra-records.env @@ -0,0 +1,8 @@ +HEADSCALE_SERVER_URL=https://hs.example.com +HEADSCALE_NOISE_PRIVATE_KEY_PATH=/var/lib/headscale/noise.key +HEADSCALE_PREFIXES_V4=100.64.0.0/10 +HEADSCALE_DATABASE_TYPE=sqlite +HEADSCALE_DATABASE_SQLITE_PATH=/var/lib/headscale/db.sqlite +HEADSCALE_DNS_MAGIC_DNS=false +HEADSCALE_DNS_OVERRIDE_LOCAL_DNS=false +HEADSCALE_DNS_EXTRA_RECORDS=[{"name":"a.example.com","type":"A","value":"100.64.0.1"}] diff --git a/hscontrol/types/testdata/compat/env-legacy-ignored.env b/hscontrol/types/testdata/compat/env-legacy-ignored.env new file mode 100644 index 000000000..10ff4c759 --- /dev/null +++ b/hscontrol/types/testdata/compat/env-legacy-ignored.env @@ -0,0 +1,14 @@ +HEADSCALE_SERVER_URL=https://hs.example.com +HEADSCALE_NOISE_PRIVATE_KEY_PATH=/var/lib/headscale/noise.key +HEADSCALE_PREFIXES_V4=100.64.0.0/10 +HEADSCALE_DATABASE_TYPE=sqlite +HEADSCALE_DATABASE_SQLITE_PATH=/var/lib/headscale/db.sqlite +HEADSCALE_DNS_MAGIC_DNS=false +HEADSCALE_DNS_OVERRIDE_LOCAL_DNS=false +HEADSCALE_TLS_CERT_PATH=/etc/headscale/tls.crt +HEADSCALE_TLS_KEY_PATH=/etc/headscale/tls.key +HEADSCALE_DNS_CONFIG_MAGIC_DNS=true +HEADSCALE_DATABASE_GORM_PREPARE_STMT=true +HEADSCALE_DB_TYPE=postgres +HEADSCALE_PRIVATE_KEY_PATH=/tmp/private.key +HEADSCALE_EPHEMERAL_NODE_INACTIVITY_TIMEOUT=30m diff --git a/hscontrol/types/testdata/compat/env-legacy-removed.env b/hscontrol/types/testdata/compat/env-legacy-removed.env new file mode 100644 index 000000000..11a6e9594 --- /dev/null +++ b/hscontrol/types/testdata/compat/env-legacy-removed.env @@ -0,0 +1,10 @@ +HEADSCALE_SERVER_URL=https://hs.example.com +HEADSCALE_NOISE_PRIVATE_KEY_PATH=/var/lib/headscale/noise.key +HEADSCALE_PREFIXES_V4=100.64.0.0/10 +HEADSCALE_DATABASE_TYPE=sqlite +HEADSCALE_DATABASE_SQLITE_PATH=/var/lib/headscale/db.sqlite +HEADSCALE_DNS_MAGIC_DNS=false +HEADSCALE_DNS_OVERRIDE_LOCAL_DNS=false +HEADSCALE_ACL_POLICY_PATH=/etc/headscale/acl.hujson +HEADSCALE_RANDOMIZE_CLIENT_PORT=true +HEADSCALE_OIDC_EXPIRY=1d diff --git a/hscontrol/types/testdata/compat/env-lists-maps.env b/hscontrol/types/testdata/compat/env-lists-maps.env new file mode 100644 index 000000000..c13057faf --- /dev/null +++ b/hscontrol/types/testdata/compat/env-lists-maps.env @@ -0,0 +1,11 @@ +HEADSCALE_SERVER_URL=https://hs.example.com +HEADSCALE_NOISE_PRIVATE_KEY_PATH=/var/lib/headscale/noise.key +HEADSCALE_PREFIXES_V4=100.64.0.0/10 +HEADSCALE_DATABASE_TYPE=sqlite +HEADSCALE_DATABASE_SQLITE_PATH=/var/lib/headscale/db.sqlite +HEADSCALE_DNS_MAGIC_DNS=false +HEADSCALE_DNS_OVERRIDE_LOCAL_DNS=false +HEADSCALE_DNS_NAMESERVERS_GLOBAL=1.1.1.1 8.8.8.8 +HEADSCALE_DNS_NAMESERVERS_SPLIT={"corp.example.com":["10.0.0.1"]} +HEADSCALE_OIDC_EXTRA_PARAMS={"domain_hint":"example.com"} +HEADSCALE_DNS_SEARCH_DOMAINS=a.example.com b.example.com diff --git a/hscontrol/types/testdata/compat/env-only.env b/hscontrol/types/testdata/compat/env-only.env new file mode 100644 index 000000000..6b8668056 --- /dev/null +++ b/hscontrol/types/testdata/compat/env-only.env @@ -0,0 +1,7 @@ +HEADSCALE_SERVER_URL=https://hs.example.com +HEADSCALE_NOISE_PRIVATE_KEY_PATH=/var/lib/headscale/noise.key +HEADSCALE_PREFIXES_V4=100.64.0.0/10 +HEADSCALE_DATABASE_TYPE=sqlite +HEADSCALE_DATABASE_SQLITE_PATH=/var/lib/headscale/db.sqlite +HEADSCALE_DNS_MAGIC_DNS=false +HEADSCALE_DNS_OVERRIDE_LOCAL_DNS=false diff --git a/hscontrol/types/testdata/compat/env-precedence.env b/hscontrol/types/testdata/compat/env-precedence.env new file mode 100644 index 000000000..4c1656b6a --- /dev/null +++ b/hscontrol/types/testdata/compat/env-precedence.env @@ -0,0 +1,4 @@ +HEADSCALE_LOG_LEVEL=warn +HEADSCALE_DNS_NAMESERVERS_SPLIT={"b.example.com":["10.0.0.2"]} +HEADSCALE_DNS_SEARCH_DOMAINS=y.example.com +HEADSCALE_OIDC_EXTRA_PARAMS={"c":"d"} diff --git a/hscontrol/types/testdata/compat/env-precedence.yaml b/hscontrol/types/testdata/compat/env-precedence.yaml new file mode 100644 index 000000000..9a00b9a39 --- /dev/null +++ b/hscontrol/types/testdata/compat/env-precedence.yaml @@ -0,0 +1,21 @@ +server_url: https://hs.example.com +noise: + private_key_path: /var/lib/headscale/noise.key +prefixes: + v4: 100.64.0.0/10 +database: + type: sqlite + sqlite: + path: /var/lib/headscale/db.sqlite +dns: + magic_dns: false + override_local_dns: false + nameservers: + split: + a.example.com: [10.0.0.1] + search_domains: [x.example.com] +log: + level: debug +oidc: + extra_params: + a: b diff --git a/hscontrol/types/testdata/compat/env-secrets.env b/hscontrol/types/testdata/compat/env-secrets.env new file mode 100644 index 000000000..d0d428856 --- /dev/null +++ b/hscontrol/types/testdata/compat/env-secrets.env @@ -0,0 +1,12 @@ +HEADSCALE_SERVER_URL=https://hs.example.com +HEADSCALE_NOISE_PRIVATE_KEY_PATH=/var/lib/headscale/noise.key +HEADSCALE_PREFIXES_V4=100.64.0.0/10 +HEADSCALE_DATABASE_TYPE=sqlite +HEADSCALE_DATABASE_SQLITE_PATH=/var/lib/headscale/db.sqlite +HEADSCALE_DNS_MAGIC_DNS=false +HEADSCALE_DNS_OVERRIDE_LOCAL_DNS=false +HEADSCALE_DATABASE_POSTGRES_PASS=marker-postgres-pass +HEADSCALE_CLI_API_KEY=marker-cli-api-key +HEADSCALE_OIDC_ISSUER=https://idp.example.com +HEADSCALE_OIDC_CLIENT_ID=marker-client-id +HEADSCALE_OIDC_CLIENT_SECRET=marker-oidc-secret diff --git a/hscontrol/types/testdata/compat/env-shapes.env b/hscontrol/types/testdata/compat/env-shapes.env new file mode 100644 index 000000000..a1785a692 --- /dev/null +++ b/hscontrol/types/testdata/compat/env-shapes.env @@ -0,0 +1,23 @@ +HEADSCALE_SERVER_URL=https://hs.example.com +HEADSCALE_NOISE_PRIVATE_KEY_PATH=/var/lib/headscale/noise.key +HEADSCALE_PREFIXES_V4=100.64.0.0/10 +HEADSCALE_DATABASE_TYPE=sqlite +HEADSCALE_DATABASE_SQLITE_PATH=/var/lib/headscale/db.sqlite +HEADSCALE_DNS_MAGIC_DNS=false +HEADSCALE_DNS_OVERRIDE_LOCAL_DNS=false +# Lists: JSON arrays, commas and padding are not parsed. +HEADSCALE_DNS_SEARCH_DOMAINS=["a.example.com","b.example.com"] +HEADSCALE_DNS_NAMESERVERS_GLOBAL=1.1.1.1,8.8.8.8 +HEADSCALE_OIDC_ALLOWED_DOMAINS=["example.com"] +HEADSCALE_OIDC_ALLOWED_GROUPS= a b +HEADSCALE_DERP_URLS=https://a.example.com/derp.json https://b.example.com/derp.json +HEADSCALE_TRUSTED_PROXIES=10.0.0.0/8 192.168.0.0/16 +# Maps: non-JSON value, non-string value, key case. +HEADSCALE_DNS_NAMESERVERS_SPLIT=corp.example.com=10.0.0.1 +HEADSCALE_OIDC_EXTRA_PARAMS={"Domain_Hint":"env","n":1} +# Scalars: durations without unit, octal mode, numeric bool. +HEADSCALE_TUNING_BATCH_CHANGE_DELAY=800 +HEADSCALE_DERP_UPDATE_FREQUENCY=30 +HEADSCALE_NODE_EXPIRY=90 +HEADSCALE_UNIX_SOCKET_PERMISSION=0700 +HEADSCALE_TAILDROP_ENABLED=0 diff --git a/hscontrol/types/testdata/compat/example-main.yaml b/hscontrol/types/testdata/compat/example-main.yaml new file mode 100644 index 000000000..1e78d0b17 --- /dev/null +++ b/hscontrol/types/testdata/compat/example-main.yaml @@ -0,0 +1,526 @@ +--- +# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order: +# +# - `/etc/headscale` +# - `~/.headscale` +# - current working directory + +# The url clients will connect to. +# Typically this will be a domain like: +# +# https://myheadscale.example.com:443 +# +server_url: http://127.0.0.1:8080 + +# Address to listen to / bind to on the server +# +# For production: +# listen_addr: 0.0.0.0:8080 +listen_addr: 127.0.0.1:8080 + +# Address to listen to /metrics and /debug, you may want +# to keep this endpoint private to your internal network +# Use an empty value to disable the metrics listener. +metrics_listen_addr: 127.0.0.1:9090 + +# CIDR(s) of reverse proxies (e.g. 127.0.0.1/32) whose +# True-Client-IP, X-Real-IP and X-Forwarded-For headers should +# be honoured. Empty (default) ignores those headers; setting +# this without a proxy in front lets clients spoof their source +# IP in logs and in the v2 API's ip:publicAddress. +trusted_proxies: [] + +# The Noise section includes specific configuration for the +# TS2021 Noise protocol +noise: + # The Noise private key is used to encrypt the traffic between headscale and + # Tailscale clients when using the new Noise-based protocol. A missing key + # will be automatically generated. + private_key_path: /var/lib/headscale/noise_private.key + +# List of IP prefixes to allocate tailaddresses from. +# Each prefix consists of either an IPv4 or IPv6 address, +# and the associated prefix length, delimited by a slash. +# +# WARNING: These prefixes MUST be subsets of the standard Tailscale ranges: +# - IPv4: 100.64.0.0/10 (CGNAT range) +# - IPv6: fd7a:115c:a1e0::/48 (Tailscale ULA range) +# +# Using a SUBSET of these ranges is supported and useful if you want to +# limit IP allocation to a smaller block (e.g., 100.64.0.0/24). +# +# Using ranges OUTSIDE of CGNAT/ULA is NOT supported and will cause +# undefined behaviour. The Tailscale client has hard-coded assumptions +# about these ranges and will break in subtle, hard-to-debug ways. +# +# See: +# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33 +# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71 +prefixes: + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 + + # Strategy used for allocation of IPs to nodes, available options: + # - sequential (default): assigns the next free IP from the previous given + # IP. A best-effort approach is used and Headscale might leave holes in the + # IP range or fill up existing holes in the IP range. + # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand). + allocation: sequential + +# DERP is a relay system that Tailscale uses when a direct +# connection cannot be established. +# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp +# +# Headscale needs a list of DERP servers that can be presented to the clients. +derp: + server: + # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config + # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place + enabled: false + + # Region ID to use for the embedded DERP server. + # The local DERP prevails if the region ID collides with other region ID coming from + # the regular DERP config. + region_id: 999 + + # Region code and name are displayed in the Tailscale UI to identify a DERP region + region_code: "headscale" + region_name: "Headscale Embedded DERP" + + # Only allow clients associated with this server access + verify_clients: true + + # Listens over UDP at the configured address for STUN connections - to help with NAT traversal. + # When the embedded DERP server is enabled stun_listen_addr MUST be defined. + # + # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/ + stun_listen_addr: "0.0.0.0:3478" + + # Private key used to encrypt the traffic between headscale DERP and + # Tailscale clients. A missing key will be automatically generated. + private_key_path: /var/lib/headscale/derp_server_private.key + + # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically, + # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths + # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths + automatically_add_embedded_derp_region: true + + # For better connection stability (especially when using an Exit-Node and DNS is not working), + # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using: + ipv4: 198.51.100.1 + ipv6: 2001:db8::1 + + # List of externally available DERP maps encoded in JSON. + # A URL or path that fails to load is logged and skipped; headscale only + # refuses to start when no DERP region remains. + urls: + - https://controlplane.tailscale.com/derpmap/default + + # Locally available DERP map files. The extension picks the format: .yaml/.yml, + # or Tailscale JSON as .json or .hujson. Both JSON extensions accept comments + # and trailing commas. + # + # This option is mostly interesting for people hosting their own DERP servers: + # https://tailscale.com/docs/reference/derp-servers/custom-derp-servers + # https://headscale.net/stable/ref/derp/ + # + # paths: + # - /etc/headscale/derp-example.yaml + paths: [] + + # If enabled, a worker will be set up to periodically + # refresh the given sources and update the derpmap + # will be set up. + auto_update_enabled: true + + # How often should we check for DERP updates? + update_frequency: 3h + +# Disables the automatic check for headscale updates on startup +disable_check_updates: false + +# Node lifecycle configuration. +node: + # Default key expiry for non-tagged nodes, regardless of registration method + # (auth key, CLI, web auth). Tagged nodes are exempt and never expire. + # + # This is the base default. OIDC can override this via oidc.expiry. + # If a client explicitly requests a specific expiry, the client value is used. + # + # Setting the value to "0" means no default expiry (nodes never expire unless + # explicitly expired via `headscale nodes expire`). + # + # Tailscale SaaS uses 180d; set to a positive duration to match that behaviour. + # + # Default: 0 (no default expiry) + expiry: 0 + + ephemeral: + # Time before an inactive ephemeral node is deleted. + inactivity_timeout: 30m + + # HA subnet router health probing. + # + # When HA routes exist (2+ nodes advertising the same prefix), headscale + # pings each HA node every probe_interval via the Noise channel. If a node + # fails to respond within probe_timeout it is marked unhealthy and the + # primary role moves to the next healthy node. A node that later responds + # is marked healthy again but does NOT reclaim primary (avoids flapping). + # + # Worst-case detection time is probe_interval + probe_timeout (15s default). + # No-op when no HA routes exist. Set probe_interval to 0 to disable. + routes: + ha: + # How often to ping HA subnet routers. Set to 0 to disable probing. + # Must be >= 2s when enabled. + probe_interval: 10s + + # How long to wait for a ping response before marking a node unhealthy. + # Must be >= 1s and less than probe_interval. + probe_timeout: 5s + +database: + # Database type. Available options: sqlite, postgres + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # All new development, testing and optimisations are done with SQLite in mind. + type: sqlite + + # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace". + debug: false + + # GORM configuration settings. + gorm: + # Enable parameterized queries. + parameterized_queries: true + + # Skip logging "record not found" errors. + skip_err_record_not_found: true + + # Threshold for slow queries in milliseconds. + slow_threshold: 1000 + + # SQLite config + sqlite: + path: /var/lib/headscale/db.sqlite + + # Enable WAL mode for SQLite. This is recommended for production environments. + # https://www.sqlite.org/wal.html + write_ahead_log: true + + # Maximum number of WAL file frames before the WAL file is automatically checkpointed. + # https://www.sqlite.org/c3ref/wal_autocheckpoint.html + # Set to 0 to disable automatic checkpointing. + wal_autocheckpoint: 1000 + + # # Postgres config + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # See database.type for more information. + # postgres: + # # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank. + # host: localhost + # port: 5432 + # name: headscale + # user: foo + # pass: bar + # max_open_conns: 10 + # max_idle_conns: 10 + # conn_max_idle_time_secs: 3600 + + # # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need + # # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1. + # ssl: false + +### TLS configuration +# See: https://headscale.net/stable/ref/tls/ +tls: + ## Use already defined certificates: + cert_path: "" + key_path: "" + + ## Let's Encrypt / ACME + # Headscale supports automatically requesting and setting up + # TLS for a domain with Let's Encrypt. + acme: + # Domain name to request a TLS certificate for: + hostname: "" + + # Type of ACME challenge to use, currently supported types: + # HTTP-01, TLS-ALPN-01 or DNS-01 (uses dns.challenge) + challenge_type: HTTP-01 + + # When HTTP-01 challenge is chosen, letsencrypt must set up a + # verification endpoint, and it will be listening on: + # :http = port 80 + http_listen: ":http" + + # URL to ACME directory + url: https://acme-v02.api.letsencrypt.org/directory + + # Email to register with ACME provider + email: "" + + # Path to store certificates and metadata needed by letsencrypt + cache_dir: /var/lib/headscale/cache + +log: + # Valid log levels: panic, fatal, error, warn, info, debug, trace + level: info + + # Output formatting for logs: text or json + format: text + +## Policy +# Headscale supports a wide range of Tailscale policy features such as ACLs and +# Grants. Please have a look at their docs to better understand the concepts: +# ACLs: https://tailscale.com/docs/features/access-control/acls +# Grants: https://tailscale.com/docs/features/access-control/grants +policy: + # The mode can be "file" or "database" that defines + # where the policies are stored and read from. + mode: file + + # If the mode is set to "file", the path to a HuJSON file containing policies. + path: "" + +## DNS +# +# headscale supports Tailscale's DNS configuration and MagicDNS. +# Please have a look to their docs to better understand the concepts: +# +# - https://tailscale.com/docs/features/magicdns +# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns +# +# Please note that for the DNS configuration to have any effect, +# clients must have the `--accept-dns=true` option enabled. This is the +# default for the Tailscale client. This option is enabled by default +# in the Tailscale client. +# +# Setting _any_ of the configuration and `--accept-dns=true` on the +# clients will integrate with the DNS manager on the client or +# overwrite /etc/resolv.conf. +# https://tailscale.com/docs/reference/faq/dns-resolv-conf +# +# If you want stop Headscale from managing the DNS configuration +# all the fields under `dns` should be set to empty values. +dns: + # Whether to use MagicDNS + magic_dns: true + + # Defines the base domain to create the hostnames for MagicDNS. + # This domain _must_ be different from the server_url domain. + # `base_domain` must be a FQDN, without the trailing dot. + # The FQDN of the hosts will be + # `hostname.base_domain` (e.g., _myhost.example.com_). + base_domain: example.com + + # Whether to use the local DNS settings of a node or override the local DNS + # settings (default) and force the use of Headscale's DNS configuration. + override_local_dns: true + + # List of DNS servers to expose to clients. + nameservers: + global: + - 1.1.1.1 + - 1.0.0.1 + - 2606:4700:4700::1111 + - 2606:4700:4700::1001 + + # NextDNS (see https://tailscale.com/docs/integrations/nextdns). + # "abc123" is example NextDNS ID, replace with yours. + # - https://dns.nextdns.io/abc123 + + # Split DNS (see https://tailscale.com/docs/reference/dns-in-tailscale#restricted-nameservers), + # a map of domains and which DNS server to use for each. + split: {} + # foo.bar.com: + # - 1.1.1.1 + # darp.headscale.net: + # - 1.1.1.1 + # - 8.8.8.8 + + # Set custom DNS search domains. With MagicDNS enabled, + # your tailnet base_domain is always the first search domain. + search_domains: [] + + # Extra DNS records + # so far only A and AAAA records are supported (on the tailscale side) + # See: https://headscale.net/stable/ref/dns/ + extra_records: [] + # - name: "grafana.myvpn.example.com" + # type: "A" + # value: "100.64.0.3" + # + # # you can also put it in one line + # - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" } + # + # Alternatively, extra DNS records can be loaded from a file. The extension + # picks the format: .json, .hujson, .yaml or .yml. Both JSON extensions + # accept comments and trailing commas. + # Headscale processes this file on each change. + # extra_records_path: /var/lib/headscale/extra-records.json + + # Let nodes get TLS certificates for their MagicDNS name with + # `tailscale cert`. Requires dns.challenge.provider. + certificates: + enabled: false + + # DNS zone the provider writes to. Defaults to base_domain. + # zone: example.com + + # DNS provider for ACME DNS-01 challenges, used by dns.certificates and + # by tls.acme with challenge_type DNS-01. + challenge: + # How long to wait for a record to show up on every authoritative + # nameserver. 0 disables the check. + propagation_timeout: 2m + + # Resolvers used to find the zone's nameservers. + # Defaults to 1.1.1.1 and 8.8.8.8. + # resolvers: [] + + # acmedns, cloudflare, gigahost, hetzner, powerdns or rfc2136. The other + # keys are settings of that provider; add _path to a key to read it from + # a file. + # provider: + # name: cloudflare + # api_token_path: /run/credentials/headscale.service/cloudflare-token + # + # acmedns needs a registration per certificate name under config, and + # each _acme-challenge name CNAMEd to its registration's fulldomain. A + # node without one gets no certificate. A registration holds two + # pending challenges; more are refused until one expires. One account + # (username, password, subdomain and server_url instead of config) + # serves headscale's own certificate only. + # provider: + # name: acmedns + # config: + # laptop.example.com: + # username: + # password: + # subdomain: + # server_url: https://auth.acme-dns.io + +# Unix socket used for the CLI to connect without authentication +# Note: for production you will want to set this to something like: +unix_socket: /var/run/headscale/headscale.sock +# Octal, quoted: YAML reads an unquoted 0770 as the number 504. +unix_socket_permission: "0770" + +# OpenID Connect +# https://headscale.net/stable/ref/oidc/ +# oidc: +# # Block startup until the identity provider is available and healthy. +# only_start_if_oidc_is_available: true +# +# # OpenID Connect Issuer URL from the identity provider +# issuer: "https://your-oidc.issuer.com/path" +# +# # Client ID from the identity provider +# client_id: "your-oidc-client-id" +# +# # Client secret generated by the identity provider +# # Note: client_secret and client_secret_path are mutually exclusive. +# client_secret: "your-oidc-client-secret" +# # Alternatively, set `client_secret_path` to read the secret from the file. +# # It resolves environment variables, making integration to systemd's +# # `LoadCredential` straightforward: +# client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret" +# +# # Use the expiry from the token received from OpenID when the user logged +# # in. This will typically lead to frequent need to reauthenticate and should +# # only be enabled if you know what you are doing. +# # Note: enabling this will cause `node.expiry` to be ignored for +# # OIDC-authenticated nodes. +# use_expiry_from_token: false +# +# # The OIDC scopes to use, defaults to "openid", "profile" and "email". +# # Custom scopes can be configured as needed, be sure to always include the +# # required "openid" scope. +# scope: ["openid", "profile", "email"] +# +# # Only verified email addresses are synchronized to the user profile by +# # default. Unverified emails may be allowed in case an identity provider +# # does not send the "email_verified: true" claim or email verification is +# # not required. +# email_verified_required: true +# +# # Provide custom key/value pairs which get sent to the identity provider's +# # authorization endpoint. +# extra_params: +# domain_hint: example.com +# +# # Only accept users whose email domain is part of the allowed_domains list. +# allowed_domains: +# - example.com +# +# # Only accept users whose email address is part of the allowed_users list. +# allowed_users: +# - alice@example.com +# +# # Only accept users which are members of at least one group in the +# # allowed_groups list. +# allowed_groups: +# - /headscale +# +# # Optional: PKCE (Proof Key for Code Exchange) configuration +# # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow +# # by preventing authorization code interception attacks +# # See https://datatracker.ietf.org/doc/html/rfc7636 +# pkce: +# # Enable or disable PKCE support (default: false) +# enabled: false +# +# # PKCE method to use: +# # - plain: Use plain code verifier +# # - S256: Use SHA256 hashed code verifier (default, recommended) +# method: S256 + +# Logtail configuration +# Logtail is Tailscales logging and auditing infrastructure, it allows the +# control panel to instruct tailscale nodes to log their activity to a remote +# server. To disable logging on the client side, please refer to: +# https://tailscale.com/docs/features/logging#opt-out-of-client-logging +logtail: + # Enable logtail for tailscale nodes of this Headscale instance. + # As there is currently no support for overriding the log server in Headscale, this is + # disabled by default. Enabling this will make your clients send logs to Tailscale Inc. + enabled: false + +# Taildrop configuration +# Taildrop is the file sharing feature of Tailscale, allowing nodes to +# send files to each other. +# https://tailscale.com/docs/features/taildrop +taildrop: + # Enable or disable Taildrop tailnet-wide. When disabled, headscale + # withholds `https://tailscale.com/cap/file-sharing` from every + # node's CapMap. + enabled: true + +# Default node auto-update behaviour. When enabled, every node's +# CapMap carries `default-auto-update: [true]` so clients that have +# not made a local opt-in / opt-out choice run auto-updates by +# default. Setting it back to false flips the default for future +# clients; clients that already stored the value locally keep their +# choice. +auto_update: + enabled: false + +# Advanced performance tuning parameters. +# The defaults are carefully chosen and should rarely need adjustment. +# Only modify these if you have identified a specific performance issue. +# +# tuning: +# # Maximum number of pending registration entries in the auth cache. +# # At capacity, new registrations retry without displacing pending approvals. +# # SSH checks can use 64 additional reserved entries. Each registration +# # retains at most 64 KiB of serialized data, so the default registration +# # payload budget is 64 MiB plus record overhead. +# # +# # register_cache_max_entries: 1024 +# +# # NodeStore write batching configuration. +# # The NodeStore batches write operations before rebuilding peer relationships, +# # which is computationally expensive. Batching reduces rebuild frequency. +# # +# # node_store_batch_size: 100 +# # node_store_batch_timeout: 500ms diff --git a/hscontrol/types/testdata/compat/example-v0.23.0.yaml b/hscontrol/types/testdata/compat/example-v0.23.0.yaml new file mode 100644 index 000000000..04a2f3424 --- /dev/null +++ b/hscontrol/types/testdata/compat/example-v0.23.0.yaml @@ -0,0 +1,387 @@ +--- +# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order: +# +# - `/etc/headscale` +# - `~/.headscale` +# - current working directory + +# The url clients will connect to. +# Typically this will be a domain like: +# +# https://myheadscale.example.com:443 +# +server_url: http://127.0.0.1:8080 + +# Address to listen to / bind to on the server +# +# For production: +# listen_addr: 0.0.0.0:8080 +listen_addr: 127.0.0.1:8080 + +# Address to listen to /metrics, you may want +# to keep this endpoint private to your internal +# network +# +metrics_listen_addr: 127.0.0.1:9090 + +# Address to listen for gRPC. +# gRPC is used for controlling a headscale server +# remotely with the CLI +# Note: Remote access _only_ works if you have +# valid certificates. +# +# For production: +# grpc_listen_addr: 0.0.0.0:50443 +grpc_listen_addr: 127.0.0.1:50443 + +# Allow the gRPC admin interface to run in INSECURE +# mode. This is not recommended as the traffic will +# be unencrypted. Only enable if you know what you +# are doing. +grpc_allow_insecure: false + +# The Noise section includes specific configuration for the +# TS2021 Noise protocol +noise: + # The Noise private key is used to encrypt the + # traffic between headscale and Tailscale clients when + # using the new Noise-based protocol. + private_key_path: /var/lib/headscale/noise_private.key + +# List of IP prefixes to allocate tailaddresses from. +# Each prefix consists of either an IPv4 or IPv6 address, +# and the associated prefix length, delimited by a slash. +# It must be within IP ranges supported by the Tailscale +# client - i.e., subnets of 100.64.0.0/10 and fd7a:115c:a1e0::/48. +# See below: +# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71 +# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33 +# Any other range is NOT supported, and it will cause unexpected issues. +prefixes: + v6: fd7a:115c:a1e0::/48 + v4: 100.64.0.0/10 + + # Strategy used for allocation of IPs to nodes, available options: + # - sequential (default): assigns the next free IP from the previous given IP. + # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand). + allocation: sequential + +# DERP is a relay system that Tailscale uses when a direct +# connection cannot be established. +# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp +# +# headscale needs a list of DERP servers that can be presented +# to the clients. +derp: + server: + # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config + # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place + enabled: false + + # Region ID to use for the embedded DERP server. + # The local DERP prevails if the region ID collides with other region ID coming from + # the regular DERP config. + region_id: 999 + + # Region code and name are displayed in the Tailscale UI to identify a DERP region + region_code: "headscale" + region_name: "Headscale Embedded DERP" + + # Listens over UDP at the configured address for STUN connections - to help with NAT traversal. + # When the embedded DERP server is enabled stun_listen_addr MUST be defined. + # + # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/ + stun_listen_addr: "0.0.0.0:3478" + + # Private key used to encrypt the traffic between headscale DERP + # and Tailscale clients. + # The private key file will be autogenerated if it's missing. + # + private_key_path: /var/lib/headscale/derp_server_private.key + + # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically, + # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths + # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths + automatically_add_embedded_derp_region: true + + # For better connection stability (especially when using an Exit-Node and DNS is not working), + # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using: + ipv4: 1.2.3.4 + ipv6: 2001:db8::1 + + # List of externally available DERP maps encoded in JSON + urls: + - https://controlplane.tailscale.com/derpmap/default + + # Locally available DERP map files encoded in YAML + # + # This option is mostly interesting for people hosting + # their own DERP servers: + # https://tailscale.com/kb/1118/custom-derp-servers/ + # + # paths: + # - /etc/headscale/derp-example.yaml + paths: [] + + # If enabled, a worker will be set up to periodically + # refresh the given sources and update the derpmap + # will be set up. + auto_update_enabled: true + + # How often should we check for DERP updates? + update_frequency: 24h + +# Disables the automatic check for headscale updates on startup +disable_check_updates: false + +# Time before an inactive ephemeral node is deleted? +ephemeral_node_inactivity_timeout: 30m + +database: + # Database type. Available options: sqlite, postgres + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # All new development, testing and optimisations are done with SQLite in mind. + type: sqlite + + # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace". + debug: false + + # GORM configuration settings. + gorm: + # Enable prepared statements. + prepare_stmt: true + + # Enable parameterized queries. + parameterized_queries: true + + # Skip logging "record not found" errors. + skip_err_record_not_found: true + + # Threshold for slow queries in milliseconds. + slow_threshold: 1000 + + # SQLite config + sqlite: + path: /var/lib/headscale/db.sqlite + + # Enable WAL mode for SQLite. This is recommended for production environments. + # https://www.sqlite.org/wal.html + write_ahead_log: true + + # # Postgres config + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # See database.type for more information. + # postgres: + # # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank. + # host: localhost + # port: 5432 + # name: headscale + # user: foo + # pass: bar + # max_open_conns: 10 + # max_idle_conns: 10 + # conn_max_idle_time_secs: 3600 + + # # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need + # # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1. + # ssl: false + +### TLS configuration +# +## Let's encrypt / ACME +# +# headscale supports automatically requesting and setting up +# TLS for a domain with Let's Encrypt. +# +# URL to ACME directory +acme_url: https://acme-v02.api.letsencrypt.org/directory + +# Email to register with ACME provider +acme_email: "" + +# Domain name to request a TLS certificate for: +tls_letsencrypt_hostname: "" + +# Path to store certificates and metadata needed by +# letsencrypt +# For production: +tls_letsencrypt_cache_dir: /var/lib/headscale/cache + +# Type of ACME challenge to use, currently supported types: +# HTTP-01 or TLS-ALPN-01 +# See [docs/tls.md](docs/tls.md) for more information +tls_letsencrypt_challenge_type: HTTP-01 +# When HTTP-01 challenge is chosen, letsencrypt must set up a +# verification endpoint, and it will be listening on: +# :http = port 80 +tls_letsencrypt_listen: ":http" + +## Use already defined certificates: +tls_cert_path: "" +tls_key_path: "" + +log: + # Output formatting for logs: text or json + format: text + level: info + +## Policy +# headscale supports Tailscale's ACL policies. +# Please have a look to their KB to better +# understand the concepts: https://tailscale.com/kb/1018/acls/ +policy: + # The mode can be "file" or "database" that defines + # where the ACL policies are stored and read from. + mode: file + # If the mode is set to "file", the path to a + # HuJSON file containing ACL policies. + path: "" + +## DNS +# +# headscale supports Tailscale's DNS configuration and MagicDNS. +# Please have a look to their KB to better understand the concepts: +# +# - https://tailscale.com/kb/1054/dns/ +# - https://tailscale.com/kb/1081/magicdns/ +# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns/ +# +# Please note that for the DNS configuration to have any effect, +# clients must have the `--accept-dns=true` option enabled. This is the +# default for the Tailscale client. This option is enabled by default +# in the Tailscale client. +# +# Setting _any_ of the configuration and `--accept-dns=true` on the +# clients will integrate with the DNS manager on the client or +# overwrite /etc/resolv.conf. +# https://tailscale.com/kb/1235/resolv-conf +# +# If you want stop Headscale from managing the DNS configuration +# all the fields under `dns` should be set to empty values. +dns: + # Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/). + # Only works if there is at least a nameserver defined. + magic_dns: true + + # Defines the base domain to create the hostnames for MagicDNS. + # This domain _must_ be different from the server_url domain. + # `base_domain` must be a FQDN, without the trailing dot. + # The FQDN of the hosts will be + # `hostname.base_domain` (e.g., _myhost.example.com_). + base_domain: example.com + + # List of DNS servers to expose to clients. + nameservers: + global: + - 1.1.1.1 + - 1.0.0.1 + - 2606:4700:4700::1111 + - 2606:4700:4700::1001 + + # NextDNS (see https://tailscale.com/kb/1218/nextdns/). + # "abc123" is example NextDNS ID, replace with yours. + # - https://dns.nextdns.io/abc123 + + # Split DNS (see https://tailscale.com/kb/1054/dns/), + # a map of domains and which DNS server to use for each. + split: + {} + # foo.bar.com: + # - 1.1.1.1 + # darp.headscale.net: + # - 1.1.1.1 + # - 8.8.8.8 + + # Set custom DNS search domains. With MagicDNS enabled, + # your tailnet base_domain is always the first search domain. + search_domains: [] + + # Extra DNS records + # so far only A-records are supported (on the tailscale side) + # See https://github.com/juanfont/headscale/blob/main/docs/dns-records.md#Limitations + extra_records: [] + # - name: "grafana.myvpn.example.com" + # type: "A" + # value: "100.64.0.3" + # + # # you can also put it in one line + # - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" } + + # DEPRECATED + # Use the username as part of the DNS name for nodes, with this option enabled: + # node1.username.example.com + # while when this is disabled: + # node1.example.com + # This is a legacy option as Headscale has have this wrongly implemented + # while in upstream Tailscale, the username is not included. + use_username_in_magic_dns: false + +# Unix socket used for the CLI to connect without authentication +# Note: for production you will want to set this to something like: +unix_socket: /var/run/headscale/headscale.sock +unix_socket_permission: "0770" +# +# headscale supports experimental OpenID connect support, +# it is still being tested and might have some bugs, please +# help us test it. +# OpenID Connect +# oidc: +# only_start_if_oidc_is_available: true +# issuer: "https://your-oidc.issuer.com/path" +# client_id: "your-oidc-client-id" +# client_secret: "your-oidc-client-secret" +# # Alternatively, set `client_secret_path` to read the secret from the file. +# # It resolves environment variables, making integration to systemd's +# # `LoadCredential` straightforward: +# client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret" +# # client_secret and client_secret_path are mutually exclusive. +# +# # The amount of time from a node is authenticated with OpenID until it +# # expires and needs to reauthenticate. +# # Setting the value to "0" will mean no expiry. +# expiry: 180d +# +# # Use the expiry from the token received from OpenID when the user logged +# # in, this will typically lead to frequent need to reauthenticate and should +# # only been enabled if you know what you are doing. +# # Note: enabling this will cause `oidc.expiry` to be ignored. +# use_expiry_from_token: false +# +# # Customize the scopes used in the OIDC flow, defaults to "openid", "profile" and "email" and add custom query +# # parameters to the Authorize Endpoint request. Scopes default to "openid", "profile" and "email". +# +# scope: ["openid", "profile", "email", "custom"] +# extra_params: +# domain_hint: example.com +# +# # List allowed principal domains and/or users. If an authenticated user's domain is not in this list, the +# # authentication request will be rejected. +# +# allowed_domains: +# - example.com +# # Note: Groups from keycloak have a leading '/' +# allowed_groups: +# - /headscale +# allowed_users: +# - alice@example.com +# +# # If `strip_email_domain` is set to `true`, the domain part of the username email address will be removed. +# # This will transform `first-name.last-name@example.com` to the user `first-name.last-name` +# # If `strip_email_domain` is set to `false` the domain part will NOT be removed resulting to the following +# user: `first-name.last-name.example.com` +# +# strip_email_domain: true + +# Logtail configuration +# Logtail is Tailscales logging and auditing infrastructure, it allows the control panel +# to instruct tailscale nodes to log their activity to a remote server. +logtail: + # Enable logtail for this headscales clients. + # As there is currently no support for overriding the log server in headscale, this is + # disabled by default. Enabling this will make your clients send logs to Tailscale Inc. + enabled: false + +# Enabling this option makes devices prefer a random port for WireGuard traffic over the +# default static port 41641. This option is intended as a workaround for some buggy +# firewall devices. See https://tailscale.com/kb/1181/firewalls/ for more information. +randomize_client_port: false diff --git a/hscontrol/types/testdata/compat/example-v0.24.0.yaml b/hscontrol/types/testdata/compat/example-v0.24.0.yaml new file mode 100644 index 000000000..581d997dd --- /dev/null +++ b/hscontrol/types/testdata/compat/example-v0.24.0.yaml @@ -0,0 +1,404 @@ +--- +# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order: +# +# - `/etc/headscale` +# - `~/.headscale` +# - current working directory + +# The url clients will connect to. +# Typically this will be a domain like: +# +# https://myheadscale.example.com:443 +# +server_url: http://127.0.0.1:8080 + +# Address to listen to / bind to on the server +# +# For production: +# listen_addr: 0.0.0.0:8080 +listen_addr: 127.0.0.1:8080 + +# Address to listen to /metrics, you may want +# to keep this endpoint private to your internal +# network +# +metrics_listen_addr: 127.0.0.1:9090 + +# Address to listen for gRPC. +# gRPC is used for controlling a headscale server +# remotely with the CLI +# Note: Remote access _only_ works if you have +# valid certificates. +# +# For production: +# grpc_listen_addr: 0.0.0.0:50443 +grpc_listen_addr: 127.0.0.1:50443 + +# Allow the gRPC admin interface to run in INSECURE +# mode. This is not recommended as the traffic will +# be unencrypted. Only enable if you know what you +# are doing. +grpc_allow_insecure: false + +# The Noise section includes specific configuration for the +# TS2021 Noise protocol +noise: + # The Noise private key is used to encrypt the + # traffic between headscale and Tailscale clients when + # using the new Noise-based protocol. + private_key_path: /var/lib/headscale/noise_private.key + +# List of IP prefixes to allocate tailaddresses from. +# Each prefix consists of either an IPv4 or IPv6 address, +# and the associated prefix length, delimited by a slash. +# It must be within IP ranges supported by the Tailscale +# client - i.e., subnets of 100.64.0.0/10 and fd7a:115c:a1e0::/48. +# See below: +# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71 +# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33 +# Any other range is NOT supported, and it will cause unexpected issues. +prefixes: + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 + + # Strategy used for allocation of IPs to nodes, available options: + # - sequential (default): assigns the next free IP from the previous given IP. + # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand). + allocation: sequential + +# DERP is a relay system that Tailscale uses when a direct +# connection cannot be established. +# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp +# +# headscale needs a list of DERP servers that can be presented +# to the clients. +derp: + server: + # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config + # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place + enabled: false + + # Region ID to use for the embedded DERP server. + # The local DERP prevails if the region ID collides with other region ID coming from + # the regular DERP config. + region_id: 999 + + # Region code and name are displayed in the Tailscale UI to identify a DERP region + region_code: "headscale" + region_name: "Headscale Embedded DERP" + + # Listens over UDP at the configured address for STUN connections - to help with NAT traversal. + # When the embedded DERP server is enabled stun_listen_addr MUST be defined. + # + # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/ + stun_listen_addr: "0.0.0.0:3478" + + # Private key used to encrypt the traffic between headscale DERP + # and Tailscale clients. + # The private key file will be autogenerated if it's missing. + # + private_key_path: /var/lib/headscale/derp_server_private.key + + # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically, + # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths + # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths + automatically_add_embedded_derp_region: true + + # For better connection stability (especially when using an Exit-Node and DNS is not working), + # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using: + ipv4: 1.2.3.4 + ipv6: 2001:db8::1 + + # List of externally available DERP maps encoded in JSON + urls: + - https://controlplane.tailscale.com/derpmap/default + + # Locally available DERP map files encoded in YAML + # + # This option is mostly interesting for people hosting + # their own DERP servers: + # https://tailscale.com/kb/1118/custom-derp-servers/ + # + # paths: + # - /etc/headscale/derp-example.yaml + paths: [] + + # If enabled, a worker will be set up to periodically + # refresh the given sources and update the derpmap + # will be set up. + auto_update_enabled: true + + # How often should we check for DERP updates? + update_frequency: 24h + +# Disables the automatic check for headscale updates on startup +disable_check_updates: false + +# Time before an inactive ephemeral node is deleted? +ephemeral_node_inactivity_timeout: 30m + +database: + # Database type. Available options: sqlite, postgres + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # All new development, testing and optimisations are done with SQLite in mind. + type: sqlite + + # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace". + debug: false + + # GORM configuration settings. + gorm: + # Enable prepared statements. + prepare_stmt: true + + # Enable parameterized queries. + parameterized_queries: true + + # Skip logging "record not found" errors. + skip_err_record_not_found: true + + # Threshold for slow queries in milliseconds. + slow_threshold: 1000 + + # SQLite config + sqlite: + path: /var/lib/headscale/db.sqlite + + # Enable WAL mode for SQLite. This is recommended for production environments. + # https://www.sqlite.org/wal.html + write_ahead_log: true + + # Maximum number of WAL file frames before the WAL file is automatically checkpointed. + # https://www.sqlite.org/c3ref/wal_autocheckpoint.html + # Set to 0 to disable automatic checkpointing. + wal_autocheckpoint: 1000 + + # # Postgres config + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # See database.type for more information. + # postgres: + # # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank. + # host: localhost + # port: 5432 + # name: headscale + # user: foo + # pass: bar + # max_open_conns: 10 + # max_idle_conns: 10 + # conn_max_idle_time_secs: 3600 + + # # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need + # # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1. + # ssl: false + +### TLS configuration +# +## Let's encrypt / ACME +# +# headscale supports automatically requesting and setting up +# TLS for a domain with Let's Encrypt. +# +# URL to ACME directory +acme_url: https://acme-v02.api.letsencrypt.org/directory + +# Email to register with ACME provider +acme_email: "" + +# Domain name to request a TLS certificate for: +tls_letsencrypt_hostname: "" + +# Path to store certificates and metadata needed by +# letsencrypt +# For production: +tls_letsencrypt_cache_dir: /var/lib/headscale/cache + +# Type of ACME challenge to use, currently supported types: +# HTTP-01 or TLS-ALPN-01 +# See: docs/ref/tls.md for more information +tls_letsencrypt_challenge_type: HTTP-01 +# When HTTP-01 challenge is chosen, letsencrypt must set up a +# verification endpoint, and it will be listening on: +# :http = port 80 +tls_letsencrypt_listen: ":http" + +## Use already defined certificates: +tls_cert_path: "" +tls_key_path: "" + +log: + # Output formatting for logs: text or json + format: text + level: info + +## Policy +# headscale supports Tailscale's ACL policies. +# Please have a look to their KB to better +# understand the concepts: https://tailscale.com/kb/1018/acls/ +policy: + # The mode can be "file" or "database" that defines + # where the ACL policies are stored and read from. + mode: file + # If the mode is set to "file", the path to a + # HuJSON file containing ACL policies. + path: "" + +## DNS +# +# headscale supports Tailscale's DNS configuration and MagicDNS. +# Please have a look to their KB to better understand the concepts: +# +# - https://tailscale.com/kb/1054/dns/ +# - https://tailscale.com/kb/1081/magicdns/ +# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns/ +# +# Please note that for the DNS configuration to have any effect, +# clients must have the `--accept-dns=true` option enabled. This is the +# default for the Tailscale client. This option is enabled by default +# in the Tailscale client. +# +# Setting _any_ of the configuration and `--accept-dns=true` on the +# clients will integrate with the DNS manager on the client or +# overwrite /etc/resolv.conf. +# https://tailscale.com/kb/1235/resolv-conf +# +# If you want stop Headscale from managing the DNS configuration +# all the fields under `dns` should be set to empty values. +dns: + # Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/). + magic_dns: true + + # Defines the base domain to create the hostnames for MagicDNS. + # This domain _must_ be different from the server_url domain. + # `base_domain` must be a FQDN, without the trailing dot. + # The FQDN of the hosts will be + # `hostname.base_domain` (e.g., _myhost.example.com_). + base_domain: example.com + + # List of DNS servers to expose to clients. + nameservers: + global: + - 1.1.1.1 + - 1.0.0.1 + - 2606:4700:4700::1111 + - 2606:4700:4700::1001 + + # NextDNS (see https://tailscale.com/kb/1218/nextdns/). + # "abc123" is example NextDNS ID, replace with yours. + # - https://dns.nextdns.io/abc123 + + # Split DNS (see https://tailscale.com/kb/1054/dns/), + # a map of domains and which DNS server to use for each. + split: + {} + # foo.bar.com: + # - 1.1.1.1 + # darp.headscale.net: + # - 1.1.1.1 + # - 8.8.8.8 + + # Set custom DNS search domains. With MagicDNS enabled, + # your tailnet base_domain is always the first search domain. + search_domains: [] + + # Extra DNS records + # so far only A and AAAA records are supported (on the tailscale side) + # See: docs/ref/dns.md + extra_records: [] + # - name: "grafana.myvpn.example.com" + # type: "A" + # value: "100.64.0.3" + # + # # you can also put it in one line + # - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" } + # + # Alternatively, extra DNS records can be loaded from a JSON file. + # Headscale processes this file on each change. + # extra_records_path: /var/lib/headscale/extra-records.json + +# Unix socket used for the CLI to connect without authentication +# Note: for production you will want to set this to something like: +unix_socket: /var/run/headscale/headscale.sock +unix_socket_permission: "0770" +# +# headscale supports experimental OpenID connect support, +# it is still being tested and might have some bugs, please +# help us test it. +# OpenID Connect +# oidc: +# only_start_if_oidc_is_available: true +# issuer: "https://your-oidc.issuer.com/path" +# client_id: "your-oidc-client-id" +# client_secret: "your-oidc-client-secret" +# # Alternatively, set `client_secret_path` to read the secret from the file. +# # It resolves environment variables, making integration to systemd's +# # `LoadCredential` straightforward: +# client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret" +# # client_secret and client_secret_path are mutually exclusive. +# +# # The amount of time from a node is authenticated with OpenID until it +# # expires and needs to reauthenticate. +# # Setting the value to "0" will mean no expiry. +# expiry: 180d +# +# # Use the expiry from the token received from OpenID when the user logged +# # in, this will typically lead to frequent need to reauthenticate and should +# # only been enabled if you know what you are doing. +# # Note: enabling this will cause `oidc.expiry` to be ignored. +# use_expiry_from_token: false +# +# # Customize the scopes used in the OIDC flow, defaults to "openid", "profile" and "email" and add custom query +# # parameters to the Authorize Endpoint request. Scopes default to "openid", "profile" and "email". +# +# scope: ["openid", "profile", "email", "custom"] +# extra_params: +# domain_hint: example.com +# +# # List allowed principal domains and/or users. If an authenticated user's domain is not in this list, the +# # authentication request will be rejected. +# +# allowed_domains: +# - example.com +# # Note: Groups from keycloak have a leading '/' +# allowed_groups: +# - /headscale +# allowed_users: +# - alice@example.com +# +# # Optional: PKCE (Proof Key for Code Exchange) configuration +# # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow +# # by preventing authorization code interception attacks +# # See https://datatracker.ietf.org/doc/html/rfc7636 +# pkce: +# # Enable or disable PKCE support (default: false) +# enabled: false +# # PKCE method to use: +# # - plain: Use plain code verifier +# # - S256: Use SHA256 hashed code verifier (default, recommended) +# method: S256 +# +# # Map legacy users from pre-0.24.0 versions of headscale to the new OIDC users +# # by taking the username from the legacy user and matching it with the username +# # provided by the OIDC. This is useful when migrating from legacy users to OIDC +# # to force them using the unique identifier from the OIDC and to give them a +# # proper display name and picture if available. +# # Note that this will only work if the username from the legacy user is the same +# # and there is a possibility for account takeover should a username have changed +# # with the provider. +# # Disabling this feature will cause all new logins to be created as new users. +# # Note this option will be removed in the future and should be set to false +# # on all new installations, or when all users have logged in with OIDC once. +# map_legacy_users: true + +# Logtail configuration +# Logtail is Tailscales logging and auditing infrastructure, it allows the control panel +# to instruct tailscale nodes to log their activity to a remote server. +logtail: + # Enable logtail for this headscales clients. + # As there is currently no support for overriding the log server in headscale, this is + # disabled by default. Enabling this will make your clients send logs to Tailscale Inc. + enabled: false + +# Enabling this option makes devices prefer a random port for WireGuard traffic over the +# default static port 41641. This option is intended as a workaround for some buggy +# firewall devices. See https://tailscale.com/kb/1181/firewalls/ for more information. +randomize_client_port: false diff --git a/hscontrol/types/testdata/compat/example-v0.25.0.yaml b/hscontrol/types/testdata/compat/example-v0.25.0.yaml new file mode 100644 index 000000000..f6e043c6e --- /dev/null +++ b/hscontrol/types/testdata/compat/example-v0.25.0.yaml @@ -0,0 +1,404 @@ +--- +# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order: +# +# - `/etc/headscale` +# - `~/.headscale` +# - current working directory + +# The url clients will connect to. +# Typically this will be a domain like: +# +# https://myheadscale.example.com:443 +# +server_url: http://127.0.0.1:8080 + +# Address to listen to / bind to on the server +# +# For production: +# listen_addr: 0.0.0.0:8080 +listen_addr: 127.0.0.1:8080 + +# Address to listen to /metrics, you may want +# to keep this endpoint private to your internal +# network +# +metrics_listen_addr: 127.0.0.1:9090 + +# Address to listen for gRPC. +# gRPC is used for controlling a headscale server +# remotely with the CLI +# Note: Remote access _only_ works if you have +# valid certificates. +# +# For production: +# grpc_listen_addr: 0.0.0.0:50443 +grpc_listen_addr: 127.0.0.1:50443 + +# Allow the gRPC admin interface to run in INSECURE +# mode. This is not recommended as the traffic will +# be unencrypted. Only enable if you know what you +# are doing. +grpc_allow_insecure: false + +# The Noise section includes specific configuration for the +# TS2021 Noise protocol +noise: + # The Noise private key is used to encrypt the + # traffic between headscale and Tailscale clients when + # using the new Noise-based protocol. + private_key_path: /var/lib/headscale/noise_private.key + +# List of IP prefixes to allocate tailaddresses from. +# Each prefix consists of either an IPv4 or IPv6 address, +# and the associated prefix length, delimited by a slash. +# It must be within IP ranges supported by the Tailscale +# client - i.e., subnets of 100.64.0.0/10 and fd7a:115c:a1e0::/48. +# See below: +# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71 +# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33 +# Any other range is NOT supported, and it will cause unexpected issues. +prefixes: + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 + + # Strategy used for allocation of IPs to nodes, available options: + # - sequential (default): assigns the next free IP from the previous given IP. + # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand). + allocation: sequential + +# DERP is a relay system that Tailscale uses when a direct +# connection cannot be established. +# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp +# +# headscale needs a list of DERP servers that can be presented +# to the clients. +derp: + server: + # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config + # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place + enabled: false + + # Region ID to use for the embedded DERP server. + # The local DERP prevails if the region ID collides with other region ID coming from + # the regular DERP config. + region_id: 999 + + # Region code and name are displayed in the Tailscale UI to identify a DERP region + region_code: "headscale" + region_name: "Headscale Embedded DERP" + + # Listens over UDP at the configured address for STUN connections - to help with NAT traversal. + # When the embedded DERP server is enabled stun_listen_addr MUST be defined. + # + # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/ + stun_listen_addr: "0.0.0.0:3478" + + # Private key used to encrypt the traffic between headscale DERP + # and Tailscale clients. + # The private key file will be autogenerated if it's missing. + # + private_key_path: /var/lib/headscale/derp_server_private.key + + # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically, + # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths + # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths + automatically_add_embedded_derp_region: true + + # For better connection stability (especially when using an Exit-Node and DNS is not working), + # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using: + ipv4: 1.2.3.4 + ipv6: 2001:db8::1 + + # List of externally available DERP maps encoded in JSON + urls: + - https://controlplane.tailscale.com/derpmap/default + + # Locally available DERP map files encoded in YAML + # + # This option is mostly interesting for people hosting + # their own DERP servers: + # https://tailscale.com/kb/1118/custom-derp-servers/ + # + # paths: + # - /etc/headscale/derp-example.yaml + paths: [] + + # If enabled, a worker will be set up to periodically + # refresh the given sources and update the derpmap + # will be set up. + auto_update_enabled: true + + # How often should we check for DERP updates? + update_frequency: 24h + +# Disables the automatic check for headscale updates on startup +disable_check_updates: false + +# Time before an inactive ephemeral node is deleted? +ephemeral_node_inactivity_timeout: 30m + +database: + # Database type. Available options: sqlite, postgres + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # All new development, testing and optimisations are done with SQLite in mind. + type: sqlite + + # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace". + debug: false + + # GORM configuration settings. + gorm: + # Enable prepared statements. + prepare_stmt: true + + # Enable parameterized queries. + parameterized_queries: true + + # Skip logging "record not found" errors. + skip_err_record_not_found: true + + # Threshold for slow queries in milliseconds. + slow_threshold: 1000 + + # SQLite config + sqlite: + path: /var/lib/headscale/db.sqlite + + # Enable WAL mode for SQLite. This is recommended for production environments. + # https://www.sqlite.org/wal.html + write_ahead_log: true + + # Maximum number of WAL file frames before the WAL file is automatically checkpointed. + # https://www.sqlite.org/c3ref/wal_autocheckpoint.html + # Set to 0 to disable automatic checkpointing. + wal_autocheckpoint: 1000 + + # # Postgres config + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # See database.type for more information. + # postgres: + # # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank. + # host: localhost + # port: 5432 + # name: headscale + # user: foo + # pass: bar + # max_open_conns: 10 + # max_idle_conns: 10 + # conn_max_idle_time_secs: 3600 + + # # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need + # # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1. + # ssl: false + +### TLS configuration +# +## Let's encrypt / ACME +# +# headscale supports automatically requesting and setting up +# TLS for a domain with Let's Encrypt. +# +# URL to ACME directory +acme_url: https://acme-v02.api.letsencrypt.org/directory + +# Email to register with ACME provider +acme_email: "" + +# Domain name to request a TLS certificate for: +tls_letsencrypt_hostname: "" + +# Path to store certificates and metadata needed by +# letsencrypt +# For production: +tls_letsencrypt_cache_dir: /var/lib/headscale/cache + +# Type of ACME challenge to use, currently supported types: +# HTTP-01 or TLS-ALPN-01 +# See: docs/ref/tls.md for more information +tls_letsencrypt_challenge_type: HTTP-01 +# When HTTP-01 challenge is chosen, letsencrypt must set up a +# verification endpoint, and it will be listening on: +# :http = port 80 +tls_letsencrypt_listen: ":http" + +## Use already defined certificates: +tls_cert_path: "" +tls_key_path: "" + +log: + # Output formatting for logs: text or json + format: text + level: info + +## Policy +# headscale supports Tailscale's ACL policies. +# Please have a look to their KB to better +# understand the concepts: https://tailscale.com/kb/1018/acls/ +policy: + # The mode can be "file" or "database" that defines + # where the ACL policies are stored and read from. + mode: file + # If the mode is set to "file", the path to a + # HuJSON file containing ACL policies. + path: "" + +## DNS +# +# headscale supports Tailscale's DNS configuration and MagicDNS. +# Please have a look to their KB to better understand the concepts: +# +# - https://tailscale.com/kb/1054/dns/ +# - https://tailscale.com/kb/1081/magicdns/ +# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns/ +# +# Please note that for the DNS configuration to have any effect, +# clients must have the `--accept-dns=true` option enabled. This is the +# default for the Tailscale client. This option is enabled by default +# in the Tailscale client. +# +# Setting _any_ of the configuration and `--accept-dns=true` on the +# clients will integrate with the DNS manager on the client or +# overwrite /etc/resolv.conf. +# https://tailscale.com/kb/1235/resolv-conf +# +# If you want stop Headscale from managing the DNS configuration +# all the fields under `dns` should be set to empty values. +dns: + # Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/). + magic_dns: true + + # Defines the base domain to create the hostnames for MagicDNS. + # This domain _must_ be different from the server_url domain. + # `base_domain` must be a FQDN, without the trailing dot. + # The FQDN of the hosts will be + # `hostname.base_domain` (e.g., _myhost.example.com_). + base_domain: example.com + + # List of DNS servers to expose to clients. + nameservers: + global: + - 1.1.1.1 + - 1.0.0.1 + - 2606:4700:4700::1111 + - 2606:4700:4700::1001 + + # NextDNS (see https://tailscale.com/kb/1218/nextdns/). + # "abc123" is example NextDNS ID, replace with yours. + # - https://dns.nextdns.io/abc123 + + # Split DNS (see https://tailscale.com/kb/1054/dns/), + # a map of domains and which DNS server to use for each. + split: + {} + # foo.bar.com: + # - 1.1.1.1 + # darp.headscale.net: + # - 1.1.1.1 + # - 8.8.8.8 + + # Set custom DNS search domains. With MagicDNS enabled, + # your tailnet base_domain is always the first search domain. + search_domains: [] + + # Extra DNS records + # so far only A and AAAA records are supported (on the tailscale side) + # See: docs/ref/dns.md + extra_records: [] + # - name: "grafana.myvpn.example.com" + # type: "A" + # value: "100.64.0.3" + # + # # you can also put it in one line + # - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" } + # + # Alternatively, extra DNS records can be loaded from a JSON file. + # Headscale processes this file on each change. + # extra_records_path: /var/lib/headscale/extra-records.json + +# Unix socket used for the CLI to connect without authentication +# Note: for production you will want to set this to something like: +unix_socket: /var/run/headscale/headscale.sock +unix_socket_permission: "0770" +# +# headscale supports experimental OpenID connect support, +# it is still being tested and might have some bugs, please +# help us test it. +# OpenID Connect +# oidc: +# only_start_if_oidc_is_available: true +# issuer: "https://your-oidc.issuer.com/path" +# client_id: "your-oidc-client-id" +# client_secret: "your-oidc-client-secret" +# # Alternatively, set `client_secret_path` to read the secret from the file. +# # It resolves environment variables, making integration to systemd's +# # `LoadCredential` straightforward: +# client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret" +# # client_secret and client_secret_path are mutually exclusive. +# +# # The amount of time from a node is authenticated with OpenID until it +# # expires and needs to reauthenticate. +# # Setting the value to "0" will mean no expiry. +# expiry: 180d +# +# # Use the expiry from the token received from OpenID when the user logged +# # in, this will typically lead to frequent need to reauthenticate and should +# # only been enabled if you know what you are doing. +# # Note: enabling this will cause `oidc.expiry` to be ignored. +# use_expiry_from_token: false +# +# # Customize the scopes used in the OIDC flow, defaults to "openid", "profile" and "email" and add custom query +# # parameters to the Authorize Endpoint request. Scopes default to "openid", "profile" and "email". +# +# scope: ["openid", "profile", "email", "custom"] +# extra_params: +# domain_hint: example.com +# +# # List allowed principal domains and/or users. If an authenticated user's domain is not in this list, the +# # authentication request will be rejected. +# +# allowed_domains: +# - example.com +# # Note: Groups from keycloak have a leading '/' +# allowed_groups: +# - /headscale +# allowed_users: +# - alice@example.com +# +# # Optional: PKCE (Proof Key for Code Exchange) configuration +# # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow +# # by preventing authorization code interception attacks +# # See https://datatracker.ietf.org/doc/html/rfc7636 +# pkce: +# # Enable or disable PKCE support (default: false) +# enabled: false +# # PKCE method to use: +# # - plain: Use plain code verifier +# # - S256: Use SHA256 hashed code verifier (default, recommended) +# method: S256 +# +# # Map legacy users from pre-0.24.0 versions of headscale to the new OIDC users +# # by taking the username from the legacy user and matching it with the username +# # provided by the OIDC. This is useful when migrating from legacy users to OIDC +# # to force them using the unique identifier from the OIDC and to give them a +# # proper display name and picture if available. +# # Note that this will only work if the username from the legacy user is the same +# # and there is a possibility for account takeover should a username have changed +# # with the provider. +# # When this feature is disabled, it will cause all new logins to be created as new users. +# # Note this option will be removed in the future and should be set to false +# # on all new installations, or when all users have logged in with OIDC once. +# map_legacy_users: false + +# Logtail configuration +# Logtail is Tailscales logging and auditing infrastructure, it allows the control panel +# to instruct tailscale nodes to log their activity to a remote server. +logtail: + # Enable logtail for this headscales clients. + # As there is currently no support for overriding the log server in headscale, this is + # disabled by default. Enabling this will make your clients send logs to Tailscale Inc. + enabled: false + +# Enabling this option makes devices prefer a random port for WireGuard traffic over the +# default static port 41641. This option is intended as a workaround for some buggy +# firewall devices. See https://tailscale.com/kb/1181/firewalls/ for more information. +randomize_client_port: false diff --git a/hscontrol/types/testdata/compat/example-v0.26.0.yaml b/hscontrol/types/testdata/compat/example-v0.26.0.yaml new file mode 100644 index 000000000..b62ca02ed --- /dev/null +++ b/hscontrol/types/testdata/compat/example-v0.26.0.yaml @@ -0,0 +1,391 @@ +--- +# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order: +# +# - `/etc/headscale` +# - `~/.headscale` +# - current working directory + +# The url clients will connect to. +# Typically this will be a domain like: +# +# https://myheadscale.example.com:443 +# +server_url: http://127.0.0.1:8080 + +# Address to listen to / bind to on the server +# +# For production: +# listen_addr: 0.0.0.0:8080 +listen_addr: 127.0.0.1:8080 + +# Address to listen to /metrics and /debug, you may want +# to keep this endpoint private to your internal network +metrics_listen_addr: 127.0.0.1:9090 + +# Address to listen for gRPC. +# gRPC is used for controlling a headscale server +# remotely with the CLI +# Note: Remote access _only_ works if you have +# valid certificates. +# +# For production: +# grpc_listen_addr: 0.0.0.0:50443 +grpc_listen_addr: 127.0.0.1:50443 + +# Allow the gRPC admin interface to run in INSECURE +# mode. This is not recommended as the traffic will +# be unencrypted. Only enable if you know what you +# are doing. +grpc_allow_insecure: false + +# The Noise section includes specific configuration for the +# TS2021 Noise protocol +noise: + # The Noise private key is used to encrypt the traffic between headscale and + # Tailscale clients when using the new Noise-based protocol. A missing key + # will be automatically generated. + private_key_path: /var/lib/headscale/noise_private.key + +# List of IP prefixes to allocate tailaddresses from. +# Each prefix consists of either an IPv4 or IPv6 address, +# and the associated prefix length, delimited by a slash. +# It must be within IP ranges supported by the Tailscale +# client - i.e., subnets of 100.64.0.0/10 and fd7a:115c:a1e0::/48. +# See below: +# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71 +# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33 +# Any other range is NOT supported, and it will cause unexpected issues. +prefixes: + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 + + # Strategy used for allocation of IPs to nodes, available options: + # - sequential (default): assigns the next free IP from the previous given IP. + # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand). + allocation: sequential + +# DERP is a relay system that Tailscale uses when a direct +# connection cannot be established. +# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp +# +# headscale needs a list of DERP servers that can be presented +# to the clients. +derp: + server: + # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config + # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place + enabled: false + + # Region ID to use for the embedded DERP server. + # The local DERP prevails if the region ID collides with other region ID coming from + # the regular DERP config. + region_id: 999 + + # Region code and name are displayed in the Tailscale UI to identify a DERP region + region_code: "headscale" + region_name: "Headscale Embedded DERP" + + # Listens over UDP at the configured address for STUN connections - to help with NAT traversal. + # When the embedded DERP server is enabled stun_listen_addr MUST be defined. + # + # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/ + stun_listen_addr: "0.0.0.0:3478" + + # Private key used to encrypt the traffic between headscale DERP and + # Tailscale clients. A missing key will be automatically generated. + private_key_path: /var/lib/headscale/derp_server_private.key + + # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically, + # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths + # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths + automatically_add_embedded_derp_region: true + + # For better connection stability (especially when using an Exit-Node and DNS is not working), + # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using: + ipv4: 1.2.3.4 + ipv6: 2001:db8::1 + + # List of externally available DERP maps encoded in JSON + urls: + - https://controlplane.tailscale.com/derpmap/default + + # Locally available DERP map files encoded in YAML + # + # This option is mostly interesting for people hosting + # their own DERP servers: + # https://tailscale.com/kb/1118/custom-derp-servers/ + # + # paths: + # - /etc/headscale/derp-example.yaml + paths: [] + + # If enabled, a worker will be set up to periodically + # refresh the given sources and update the derpmap + # will be set up. + auto_update_enabled: true + + # How often should we check for DERP updates? + update_frequency: 24h + +# Disables the automatic check for headscale updates on startup +disable_check_updates: false + +# Time before an inactive ephemeral node is deleted? +ephemeral_node_inactivity_timeout: 30m + +database: + # Database type. Available options: sqlite, postgres + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # All new development, testing and optimisations are done with SQLite in mind. + type: sqlite + + # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace". + debug: false + + # GORM configuration settings. + gorm: + # Enable prepared statements. + prepare_stmt: true + + # Enable parameterized queries. + parameterized_queries: true + + # Skip logging "record not found" errors. + skip_err_record_not_found: true + + # Threshold for slow queries in milliseconds. + slow_threshold: 1000 + + # SQLite config + sqlite: + path: /var/lib/headscale/db.sqlite + + # Enable WAL mode for SQLite. This is recommended for production environments. + # https://www.sqlite.org/wal.html + write_ahead_log: true + + # Maximum number of WAL file frames before the WAL file is automatically checkpointed. + # https://www.sqlite.org/c3ref/wal_autocheckpoint.html + # Set to 0 to disable automatic checkpointing. + wal_autocheckpoint: 1000 + + # # Postgres config + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # See database.type for more information. + # postgres: + # # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank. + # host: localhost + # port: 5432 + # name: headscale + # user: foo + # pass: bar + # max_open_conns: 10 + # max_idle_conns: 10 + # conn_max_idle_time_secs: 3600 + + # # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need + # # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1. + # ssl: false + +### TLS configuration +# +## Let's encrypt / ACME +# +# headscale supports automatically requesting and setting up +# TLS for a domain with Let's Encrypt. +# +# URL to ACME directory +acme_url: https://acme-v02.api.letsencrypt.org/directory + +# Email to register with ACME provider +acme_email: "" + +# Domain name to request a TLS certificate for: +tls_letsencrypt_hostname: "" + +# Path to store certificates and metadata needed by +# letsencrypt +# For production: +tls_letsencrypt_cache_dir: /var/lib/headscale/cache + +# Type of ACME challenge to use, currently supported types: +# HTTP-01 or TLS-ALPN-01 +# See: docs/ref/tls.md for more information +tls_letsencrypt_challenge_type: HTTP-01 +# When HTTP-01 challenge is chosen, letsencrypt must set up a +# verification endpoint, and it will be listening on: +# :http = port 80 +tls_letsencrypt_listen: ":http" + +## Use already defined certificates: +tls_cert_path: "" +tls_key_path: "" + +log: + # Output formatting for logs: text or json + format: text + level: info + +## Policy +# headscale supports Tailscale's ACL policies. +# Please have a look to their KB to better +# understand the concepts: https://tailscale.com/kb/1018/acls/ +policy: + # The mode can be "file" or "database" that defines + # where the ACL policies are stored and read from. + mode: file + # If the mode is set to "file", the path to a + # HuJSON file containing ACL policies. + path: "" + +## DNS +# +# headscale supports Tailscale's DNS configuration and MagicDNS. +# Please have a look to their KB to better understand the concepts: +# +# - https://tailscale.com/kb/1054/dns/ +# - https://tailscale.com/kb/1081/magicdns/ +# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns/ +# +# Please note that for the DNS configuration to have any effect, +# clients must have the `--accept-dns=true` option enabled. This is the +# default for the Tailscale client. This option is enabled by default +# in the Tailscale client. +# +# Setting _any_ of the configuration and `--accept-dns=true` on the +# clients will integrate with the DNS manager on the client or +# overwrite /etc/resolv.conf. +# https://tailscale.com/kb/1235/resolv-conf +# +# If you want stop Headscale from managing the DNS configuration +# all the fields under `dns` should be set to empty values. +dns: + # Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/). + magic_dns: true + + # Defines the base domain to create the hostnames for MagicDNS. + # This domain _must_ be different from the server_url domain. + # `base_domain` must be a FQDN, without the trailing dot. + # The FQDN of the hosts will be + # `hostname.base_domain` (e.g., _myhost.example.com_). + base_domain: example.com + + # Whether to use the local DNS settings of a node (default) or override the + # local DNS settings and force the use of Headscale's DNS configuration. + override_local_dns: false + + # List of DNS servers to expose to clients. + nameservers: + global: + - 1.1.1.1 + - 1.0.0.1 + - 2606:4700:4700::1111 + - 2606:4700:4700::1001 + + # NextDNS (see https://tailscale.com/kb/1218/nextdns/). + # "abc123" is example NextDNS ID, replace with yours. + # - https://dns.nextdns.io/abc123 + + # Split DNS (see https://tailscale.com/kb/1054/dns/), + # a map of domains and which DNS server to use for each. + split: + {} + # foo.bar.com: + # - 1.1.1.1 + # darp.headscale.net: + # - 1.1.1.1 + # - 8.8.8.8 + + # Set custom DNS search domains. With MagicDNS enabled, + # your tailnet base_domain is always the first search domain. + search_domains: [] + + # Extra DNS records + # so far only A and AAAA records are supported (on the tailscale side) + # See: docs/ref/dns.md + extra_records: [] + # - name: "grafana.myvpn.example.com" + # type: "A" + # value: "100.64.0.3" + # + # # you can also put it in one line + # - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" } + # + # Alternatively, extra DNS records can be loaded from a JSON file. + # Headscale processes this file on each change. + # extra_records_path: /var/lib/headscale/extra-records.json + +# Unix socket used for the CLI to connect without authentication +# Note: for production you will want to set this to something like: +unix_socket: /var/run/headscale/headscale.sock +unix_socket_permission: "0770" +# +# headscale supports experimental OpenID connect support, +# it is still being tested and might have some bugs, please +# help us test it. +# OpenID Connect +# oidc: +# only_start_if_oidc_is_available: true +# issuer: "https://your-oidc.issuer.com/path" +# client_id: "your-oidc-client-id" +# client_secret: "your-oidc-client-secret" +# # Alternatively, set `client_secret_path` to read the secret from the file. +# # It resolves environment variables, making integration to systemd's +# # `LoadCredential` straightforward: +# client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret" +# # client_secret and client_secret_path are mutually exclusive. +# +# # The amount of time from a node is authenticated with OpenID until it +# # expires and needs to reauthenticate. +# # Setting the value to "0" will mean no expiry. +# expiry: 180d +# +# # Use the expiry from the token received from OpenID when the user logged +# # in, this will typically lead to frequent need to reauthenticate and should +# # only been enabled if you know what you are doing. +# # Note: enabling this will cause `oidc.expiry` to be ignored. +# use_expiry_from_token: false +# +# # Customize the scopes used in the OIDC flow, defaults to "openid", "profile" and "email" and add custom query +# # parameters to the Authorize Endpoint request. Scopes default to "openid", "profile" and "email". +# +# scope: ["openid", "profile", "email", "custom"] +# extra_params: +# domain_hint: example.com +# +# # List allowed principal domains and/or users. If an authenticated user's domain is not in this list, the +# # authentication request will be rejected. +# +# allowed_domains: +# - example.com +# # Note: Groups from keycloak have a leading '/' +# allowed_groups: +# - /headscale +# allowed_users: +# - alice@example.com +# +# # Optional: PKCE (Proof Key for Code Exchange) configuration +# # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow +# # by preventing authorization code interception attacks +# # See https://datatracker.ietf.org/doc/html/rfc7636 +# pkce: +# # Enable or disable PKCE support (default: false) +# enabled: false +# # PKCE method to use: +# # - plain: Use plain code verifier +# # - S256: Use SHA256 hashed code verifier (default, recommended) +# method: S256 + +# Logtail configuration +# Logtail is Tailscales logging and auditing infrastructure, it allows the control panel +# to instruct tailscale nodes to log their activity to a remote server. +logtail: + # Enable logtail for this headscales clients. + # As there is currently no support for overriding the log server in headscale, this is + # disabled by default. Enabling this will make your clients send logs to Tailscale Inc. + enabled: false + +# Enabling this option makes devices prefer a random port for WireGuard traffic over the +# default static port 41641. This option is intended as a workaround for some buggy +# firewall devices. See https://tailscale.com/kb/1181/firewalls/ for more information. +randomize_client_port: false diff --git a/hscontrol/types/testdata/compat/example-v0.27.0.yaml b/hscontrol/types/testdata/compat/example-v0.27.0.yaml new file mode 100644 index 000000000..ec14dc036 --- /dev/null +++ b/hscontrol/types/testdata/compat/example-v0.27.0.yaml @@ -0,0 +1,409 @@ +--- +# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order: +# +# - `/etc/headscale` +# - `~/.headscale` +# - current working directory + +# The url clients will connect to. +# Typically this will be a domain like: +# +# https://myheadscale.example.com:443 +# +server_url: http://127.0.0.1:8080 + +# Address to listen to / bind to on the server +# +# For production: +# listen_addr: 0.0.0.0:8080 +listen_addr: 127.0.0.1:8080 + +# Address to listen to /metrics and /debug, you may want +# to keep this endpoint private to your internal network +metrics_listen_addr: 127.0.0.1:9090 + +# Address to listen for gRPC. +# gRPC is used for controlling a headscale server +# remotely with the CLI +# Note: Remote access _only_ works if you have +# valid certificates. +# +# For production: +# grpc_listen_addr: 0.0.0.0:50443 +grpc_listen_addr: 127.0.0.1:50443 + +# Allow the gRPC admin interface to run in INSECURE +# mode. This is not recommended as the traffic will +# be unencrypted. Only enable if you know what you +# are doing. +grpc_allow_insecure: false + +# The Noise section includes specific configuration for the +# TS2021 Noise protocol +noise: + # The Noise private key is used to encrypt the traffic between headscale and + # Tailscale clients when using the new Noise-based protocol. A missing key + # will be automatically generated. + private_key_path: /var/lib/headscale/noise_private.key + +# List of IP prefixes to allocate tailaddresses from. +# Each prefix consists of either an IPv4 or IPv6 address, +# and the associated prefix length, delimited by a slash. +# It must be within IP ranges supported by the Tailscale +# client - i.e., subnets of 100.64.0.0/10 and fd7a:115c:a1e0::/48. +# See below: +# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71 +# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33 +# Any other range is NOT supported, and it will cause unexpected issues. +prefixes: + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 + + # Strategy used for allocation of IPs to nodes, available options: + # - sequential (default): assigns the next free IP from the previous given + # IP. A best-effort approach is used and Headscale might leave holes in the + # IP range or fill up existing holes in the IP range. + # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand). + allocation: sequential + +# DERP is a relay system that Tailscale uses when a direct +# connection cannot be established. +# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp +# +# headscale needs a list of DERP servers that can be presented +# to the clients. +derp: + server: + # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config + # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place + enabled: false + + # Region ID to use for the embedded DERP server. + # The local DERP prevails if the region ID collides with other region ID coming from + # the regular DERP config. + region_id: 999 + + # Region code and name are displayed in the Tailscale UI to identify a DERP region + region_code: "headscale" + region_name: "Headscale Embedded DERP" + + # Only allow clients associated with this server access + verify_clients: true + + # Listens over UDP at the configured address for STUN connections - to help with NAT traversal. + # When the embedded DERP server is enabled stun_listen_addr MUST be defined. + # + # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/ + stun_listen_addr: "0.0.0.0:3478" + + # Private key used to encrypt the traffic between headscale DERP and + # Tailscale clients. A missing key will be automatically generated. + private_key_path: /var/lib/headscale/derp_server_private.key + + # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically, + # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths + # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths + automatically_add_embedded_derp_region: true + + # For better connection stability (especially when using an Exit-Node and DNS is not working), + # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using: + ipv4: 198.51.100.1 + ipv6: 2001:db8::1 + + # List of externally available DERP maps encoded in JSON + urls: + - https://controlplane.tailscale.com/derpmap/default + + # Locally available DERP map files encoded in YAML + # + # This option is mostly interesting for people hosting + # their own DERP servers: + # https://tailscale.com/kb/1118/custom-derp-servers/ + # + # paths: + # - /etc/headscale/derp-example.yaml + paths: [] + + # If enabled, a worker will be set up to periodically + # refresh the given sources and update the derpmap + # will be set up. + auto_update_enabled: true + + # How often should we check for DERP updates? + update_frequency: 3h + +# Disables the automatic check for headscale updates on startup +disable_check_updates: false + +# Time before an inactive ephemeral node is deleted? +ephemeral_node_inactivity_timeout: 30m + +database: + # Database type. Available options: sqlite, postgres + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # All new development, testing and optimisations are done with SQLite in mind. + type: sqlite + + # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace". + debug: false + + # GORM configuration settings. + gorm: + # Enable prepared statements. + prepare_stmt: true + + # Enable parameterized queries. + parameterized_queries: true + + # Skip logging "record not found" errors. + skip_err_record_not_found: true + + # Threshold for slow queries in milliseconds. + slow_threshold: 1000 + + # SQLite config + sqlite: + path: /var/lib/headscale/db.sqlite + + # Enable WAL mode for SQLite. This is recommended for production environments. + # https://www.sqlite.org/wal.html + write_ahead_log: true + + # Maximum number of WAL file frames before the WAL file is automatically checkpointed. + # https://www.sqlite.org/c3ref/wal_autocheckpoint.html + # Set to 0 to disable automatic checkpointing. + wal_autocheckpoint: 1000 + + # # Postgres config + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # See database.type for more information. + # postgres: + # # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank. + # host: localhost + # port: 5432 + # name: headscale + # user: foo + # pass: bar + # max_open_conns: 10 + # max_idle_conns: 10 + # conn_max_idle_time_secs: 3600 + + # # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need + # # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1. + # ssl: false + +### TLS configuration +# +## Let's encrypt / ACME +# +# headscale supports automatically requesting and setting up +# TLS for a domain with Let's Encrypt. +# +# URL to ACME directory +acme_url: https://acme-v02.api.letsencrypt.org/directory + +# Email to register with ACME provider +acme_email: "" + +# Domain name to request a TLS certificate for: +tls_letsencrypt_hostname: "" + +# Path to store certificates and metadata needed by +# letsencrypt +# For production: +tls_letsencrypt_cache_dir: /var/lib/headscale/cache + +# Type of ACME challenge to use, currently supported types: +# HTTP-01 or TLS-ALPN-01 +# See: docs/ref/tls.md for more information +tls_letsencrypt_challenge_type: HTTP-01 +# When HTTP-01 challenge is chosen, letsencrypt must set up a +# verification endpoint, and it will be listening on: +# :http = port 80 +tls_letsencrypt_listen: ":http" + +## Use already defined certificates: +tls_cert_path: "" +tls_key_path: "" + +log: + # Valid log levels: panic, fatal, error, warn, info, debug, trace + level: info + + # Output formatting for logs: text or json + format: text + +## Policy +# headscale supports Tailscale's ACL policies. +# Please have a look to their KB to better +# understand the concepts: https://tailscale.com/kb/1018/acls/ +policy: + # The mode can be "file" or "database" that defines + # where the ACL policies are stored and read from. + mode: file + # If the mode is set to "file", the path to a + # HuJSON file containing ACL policies. + path: "" + +## DNS +# +# headscale supports Tailscale's DNS configuration and MagicDNS. +# Please have a look to their KB to better understand the concepts: +# +# - https://tailscale.com/kb/1054/dns/ +# - https://tailscale.com/kb/1081/magicdns/ +# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns/ +# +# Please note that for the DNS configuration to have any effect, +# clients must have the `--accept-dns=true` option enabled. This is the +# default for the Tailscale client. This option is enabled by default +# in the Tailscale client. +# +# Setting _any_ of the configuration and `--accept-dns=true` on the +# clients will integrate with the DNS manager on the client or +# overwrite /etc/resolv.conf. +# https://tailscale.com/kb/1235/resolv-conf +# +# If you want stop Headscale from managing the DNS configuration +# all the fields under `dns` should be set to empty values. +dns: + # Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/). + magic_dns: true + + # Defines the base domain to create the hostnames for MagicDNS. + # This domain _must_ be different from the server_url domain. + # `base_domain` must be a FQDN, without the trailing dot. + # The FQDN of the hosts will be + # `hostname.base_domain` (e.g., _myhost.example.com_). + base_domain: example.com + + # Whether to use the local DNS settings of a node or override the local DNS + # settings (default) and force the use of Headscale's DNS configuration. + override_local_dns: true + + # List of DNS servers to expose to clients. + nameservers: + global: + - 1.1.1.1 + - 1.0.0.1 + - 2606:4700:4700::1111 + - 2606:4700:4700::1001 + + # NextDNS (see https://tailscale.com/kb/1218/nextdns/). + # "abc123" is example NextDNS ID, replace with yours. + # - https://dns.nextdns.io/abc123 + + # Split DNS (see https://tailscale.com/kb/1054/dns/), + # a map of domains and which DNS server to use for each. + split: {} + # foo.bar.com: + # - 1.1.1.1 + # darp.headscale.net: + # - 1.1.1.1 + # - 8.8.8.8 + + # Set custom DNS search domains. With MagicDNS enabled, + # your tailnet base_domain is always the first search domain. + search_domains: [] + + # Extra DNS records + # so far only A and AAAA records are supported (on the tailscale side) + # See: docs/ref/dns.md + extra_records: [] + # - name: "grafana.myvpn.example.com" + # type: "A" + # value: "100.64.0.3" + # + # # you can also put it in one line + # - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" } + # + # Alternatively, extra DNS records can be loaded from a JSON file. + # Headscale processes this file on each change. + # extra_records_path: /var/lib/headscale/extra-records.json + +# Unix socket used for the CLI to connect without authentication +# Note: for production you will want to set this to something like: +unix_socket: /var/run/headscale/headscale.sock +unix_socket_permission: "0770" + +# OpenID Connect +# oidc: +# # Block startup until the identity provider is available and healthy. +# only_start_if_oidc_is_available: true +# +# # OpenID Connect Issuer URL from the identity provider +# issuer: "https://your-oidc.issuer.com/path" +# +# # Client ID from the identity provider +# client_id: "your-oidc-client-id" +# +# # Client secret generated by the identity provider +# # Note: client_secret and client_secret_path are mutually exclusive. +# client_secret: "your-oidc-client-secret" +# # Alternatively, set `client_secret_path` to read the secret from the file. +# # It resolves environment variables, making integration to systemd's +# # `LoadCredential` straightforward: +# client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret" +# +# # The amount of time a node is authenticated with OpenID until it expires +# # and needs to reauthenticate. +# # Setting the value to "0" will mean no expiry. +# expiry: 180d +# +# # Use the expiry from the token received from OpenID when the user logged +# # in. This will typically lead to frequent need to reauthenticate and should +# # only be enabled if you know what you are doing. +# # Note: enabling this will cause `oidc.expiry` to be ignored. +# use_expiry_from_token: false +# +# # The OIDC scopes to use, defaults to "openid", "profile" and "email". +# # Custom scopes can be configured as needed, be sure to always include the +# # required "openid" scope. +# scope: ["openid", "profile", "email"] +# +# # Provide custom key/value pairs which get sent to the identity provider's +# # authorization endpoint. +# extra_params: +# domain_hint: example.com +# +# # Only accept users whose email domain is part of the allowed_domains list. +# allowed_domains: +# - example.com +# +# # Only accept users whose email address is part of the allowed_users list. +# allowed_users: +# - alice@example.com +# +# # Only accept users which are members of at least one group in the +# # allowed_groups list. +# allowed_groups: +# - /headscale +# +# # Optional: PKCE (Proof Key for Code Exchange) configuration +# # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow +# # by preventing authorization code interception attacks +# # See https://datatracker.ietf.org/doc/html/rfc7636 +# pkce: +# # Enable or disable PKCE support (default: false) +# enabled: false +# +# # PKCE method to use: +# # - plain: Use plain code verifier +# # - S256: Use SHA256 hashed code verifier (default, recommended) +# method: S256 + +# Logtail configuration +# Logtail is Tailscales logging and auditing infrastructure, it allows the +# control panel to instruct tailscale nodes to log their activity to a remote +# server. To disable logging on the client side, please refer to: +# https://tailscale.com/kb/1011/log-mesh-traffic#opting-out-of-client-logging +logtail: + # Enable logtail for tailscale nodes of this Headscale instance. + # As there is currently no support for overriding the log server in Headscale, this is + # disabled by default. Enabling this will make your clients send logs to Tailscale Inc. + enabled: false + +# Enabling this option makes devices prefer a random port for WireGuard traffic over the +# default static port 41641. This option is intended as a workaround for some buggy +# firewall devices. See https://tailscale.com/kb/1181/firewalls/ for more information. +randomize_client_port: false diff --git a/hscontrol/types/testdata/compat/example-v0.28.0.yaml b/hscontrol/types/testdata/compat/example-v0.28.0.yaml new file mode 100644 index 000000000..dbb08202e --- /dev/null +++ b/hscontrol/types/testdata/compat/example-v0.28.0.yaml @@ -0,0 +1,436 @@ +--- +# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order: +# +# - `/etc/headscale` +# - `~/.headscale` +# - current working directory + +# The url clients will connect to. +# Typically this will be a domain like: +# +# https://myheadscale.example.com:443 +# +server_url: http://127.0.0.1:8080 + +# Address to listen to / bind to on the server +# +# For production: +# listen_addr: 0.0.0.0:8080 +listen_addr: 127.0.0.1:8080 + +# Address to listen to /metrics and /debug, you may want +# to keep this endpoint private to your internal network +# Use an emty value to disable the metrics listener. +metrics_listen_addr: 127.0.0.1:9090 + +# Address to listen for gRPC. +# gRPC is used for controlling a headscale server +# remotely with the CLI +# Note: Remote access _only_ works if you have +# valid certificates. +# +# For production: +# grpc_listen_addr: 0.0.0.0:50443 +grpc_listen_addr: 127.0.0.1:50443 + +# Allow the gRPC admin interface to run in INSECURE +# mode. This is not recommended as the traffic will +# be unencrypted. Only enable if you know what you +# are doing. +grpc_allow_insecure: false + +# The Noise section includes specific configuration for the +# TS2021 Noise protocol +noise: + # The Noise private key is used to encrypt the traffic between headscale and + # Tailscale clients when using the new Noise-based protocol. A missing key + # will be automatically generated. + private_key_path: /var/lib/headscale/noise_private.key + +# List of IP prefixes to allocate tailaddresses from. +# Each prefix consists of either an IPv4 or IPv6 address, +# and the associated prefix length, delimited by a slash. +# It must be within IP ranges supported by the Tailscale +# client - i.e., subnets of 100.64.0.0/10 and fd7a:115c:a1e0::/48. +# See below: +# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71 +# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33 +# Any other range is NOT supported, and it will cause unexpected issues. +prefixes: + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 + + # Strategy used for allocation of IPs to nodes, available options: + # - sequential (default): assigns the next free IP from the previous given + # IP. A best-effort approach is used and Headscale might leave holes in the + # IP range or fill up existing holes in the IP range. + # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand). + allocation: sequential + +# DERP is a relay system that Tailscale uses when a direct +# connection cannot be established. +# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp +# +# headscale needs a list of DERP servers that can be presented +# to the clients. +derp: + server: + # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config + # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place + enabled: false + + # Region ID to use for the embedded DERP server. + # The local DERP prevails if the region ID collides with other region ID coming from + # the regular DERP config. + region_id: 999 + + # Region code and name are displayed in the Tailscale UI to identify a DERP region + region_code: "headscale" + region_name: "Headscale Embedded DERP" + + # Only allow clients associated with this server access + verify_clients: true + + # Listens over UDP at the configured address for STUN connections - to help with NAT traversal. + # When the embedded DERP server is enabled stun_listen_addr MUST be defined. + # + # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/ + stun_listen_addr: "0.0.0.0:3478" + + # Private key used to encrypt the traffic between headscale DERP and + # Tailscale clients. A missing key will be automatically generated. + private_key_path: /var/lib/headscale/derp_server_private.key + + # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically, + # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths + # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths + automatically_add_embedded_derp_region: true + + # For better connection stability (especially when using an Exit-Node and DNS is not working), + # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using: + ipv4: 198.51.100.1 + ipv6: 2001:db8::1 + + # List of externally available DERP maps encoded in JSON + urls: + - https://controlplane.tailscale.com/derpmap/default + + # Locally available DERP map files encoded in YAML + # + # This option is mostly interesting for people hosting + # their own DERP servers: + # https://tailscale.com/kb/1118/custom-derp-servers/ + # + # paths: + # - /etc/headscale/derp-example.yaml + paths: [] + + # If enabled, a worker will be set up to periodically + # refresh the given sources and update the derpmap + # will be set up. + auto_update_enabled: true + + # How often should we check for DERP updates? + update_frequency: 3h + +# Disables the automatic check for headscale updates on startup +disable_check_updates: false + +# Time before an inactive ephemeral node is deleted? +ephemeral_node_inactivity_timeout: 30m + +database: + # Database type. Available options: sqlite, postgres + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # All new development, testing and optimisations are done with SQLite in mind. + type: sqlite + + # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace". + debug: false + + # GORM configuration settings. + gorm: + # Enable prepared statements. + prepare_stmt: true + + # Enable parameterized queries. + parameterized_queries: true + + # Skip logging "record not found" errors. + skip_err_record_not_found: true + + # Threshold for slow queries in milliseconds. + slow_threshold: 1000 + + # SQLite config + sqlite: + path: /var/lib/headscale/db.sqlite + + # Enable WAL mode for SQLite. This is recommended for production environments. + # https://www.sqlite.org/wal.html + write_ahead_log: true + + # Maximum number of WAL file frames before the WAL file is automatically checkpointed. + # https://www.sqlite.org/c3ref/wal_autocheckpoint.html + # Set to 0 to disable automatic checkpointing. + wal_autocheckpoint: 1000 + + # # Postgres config + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # See database.type for more information. + # postgres: + # # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank. + # host: localhost + # port: 5432 + # name: headscale + # user: foo + # pass: bar + # max_open_conns: 10 + # max_idle_conns: 10 + # conn_max_idle_time_secs: 3600 + + # # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need + # # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1. + # ssl: false + +### TLS configuration +# +## Let's encrypt / ACME +# +# headscale supports automatically requesting and setting up +# TLS for a domain with Let's Encrypt. +# +# URL to ACME directory +acme_url: https://acme-v02.api.letsencrypt.org/directory + +# Email to register with ACME provider +acme_email: "" + +# Domain name to request a TLS certificate for: +tls_letsencrypt_hostname: "" + +# Path to store certificates and metadata needed by +# letsencrypt +# For production: +tls_letsencrypt_cache_dir: /var/lib/headscale/cache + +# Type of ACME challenge to use, currently supported types: +# HTTP-01 or TLS-ALPN-01 +# See: docs/ref/tls.md for more information +tls_letsencrypt_challenge_type: HTTP-01 +# When HTTP-01 challenge is chosen, letsencrypt must set up a +# verification endpoint, and it will be listening on: +# :http = port 80 +tls_letsencrypt_listen: ":http" + +## Use already defined certificates: +tls_cert_path: "" +tls_key_path: "" + +log: + # Valid log levels: panic, fatal, error, warn, info, debug, trace + level: info + + # Output formatting for logs: text or json + format: text + +## Policy +# headscale supports Tailscale's ACL policies. +# Please have a look to their KB to better +# understand the concepts: https://tailscale.com/kb/1018/acls/ +policy: + # The mode can be "file" or "database" that defines + # where the ACL policies are stored and read from. + mode: file + # If the mode is set to "file", the path to a + # HuJSON file containing ACL policies. + path: "" + +## DNS +# +# headscale supports Tailscale's DNS configuration and MagicDNS. +# Please have a look to their KB to better understand the concepts: +# +# - https://tailscale.com/kb/1054/dns/ +# - https://tailscale.com/kb/1081/magicdns/ +# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns/ +# +# Please note that for the DNS configuration to have any effect, +# clients must have the `--accept-dns=true` option enabled. This is the +# default for the Tailscale client. This option is enabled by default +# in the Tailscale client. +# +# Setting _any_ of the configuration and `--accept-dns=true` on the +# clients will integrate with the DNS manager on the client or +# overwrite /etc/resolv.conf. +# https://tailscale.com/kb/1235/resolv-conf +# +# If you want stop Headscale from managing the DNS configuration +# all the fields under `dns` should be set to empty values. +dns: + # Whether to use [MagicDNS](https://tailscale.com/kb/1081/magicdns/). + magic_dns: true + + # Defines the base domain to create the hostnames for MagicDNS. + # This domain _must_ be different from the server_url domain. + # `base_domain` must be a FQDN, without the trailing dot. + # The FQDN of the hosts will be + # `hostname.base_domain` (e.g., _myhost.example.com_). + base_domain: example.com + + # Whether to use the local DNS settings of a node or override the local DNS + # settings (default) and force the use of Headscale's DNS configuration. + override_local_dns: true + + # List of DNS servers to expose to clients. + nameservers: + global: + - 1.1.1.1 + - 1.0.0.1 + - 2606:4700:4700::1111 + - 2606:4700:4700::1001 + + # NextDNS (see https://tailscale.com/kb/1218/nextdns/). + # "abc123" is example NextDNS ID, replace with yours. + # - https://dns.nextdns.io/abc123 + + # Split DNS (see https://tailscale.com/kb/1054/dns/), + # a map of domains and which DNS server to use for each. + split: {} + # foo.bar.com: + # - 1.1.1.1 + # darp.headscale.net: + # - 1.1.1.1 + # - 8.8.8.8 + + # Set custom DNS search domains. With MagicDNS enabled, + # your tailnet base_domain is always the first search domain. + search_domains: [] + + # Extra DNS records + # so far only A and AAAA records are supported (on the tailscale side) + # See: docs/ref/dns.md + extra_records: [] + # - name: "grafana.myvpn.example.com" + # type: "A" + # value: "100.64.0.3" + # + # # you can also put it in one line + # - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" } + # + # Alternatively, extra DNS records can be loaded from a JSON file. + # Headscale processes this file on each change. + # extra_records_path: /var/lib/headscale/extra-records.json + +# Unix socket used for the CLI to connect without authentication +# Note: for production you will want to set this to something like: +unix_socket: /var/run/headscale/headscale.sock +unix_socket_permission: "0770" + +# OpenID Connect +# oidc: +# # Block startup until the identity provider is available and healthy. +# only_start_if_oidc_is_available: true +# +# # OpenID Connect Issuer URL from the identity provider +# issuer: "https://your-oidc.issuer.com/path" +# +# # Client ID from the identity provider +# client_id: "your-oidc-client-id" +# +# # Client secret generated by the identity provider +# # Note: client_secret and client_secret_path are mutually exclusive. +# client_secret: "your-oidc-client-secret" +# # Alternatively, set `client_secret_path` to read the secret from the file. +# # It resolves environment variables, making integration to systemd's +# # `LoadCredential` straightforward: +# client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret" +# +# # The amount of time a node is authenticated with OpenID until it expires +# # and needs to reauthenticate. +# # Setting the value to "0" will mean no expiry. +# expiry: 180d +# +# # Use the expiry from the token received from OpenID when the user logged +# # in. This will typically lead to frequent need to reauthenticate and should +# # only be enabled if you know what you are doing. +# # Note: enabling this will cause `oidc.expiry` to be ignored. +# use_expiry_from_token: false +# +# # The OIDC scopes to use, defaults to "openid", "profile" and "email". +# # Custom scopes can be configured as needed, be sure to always include the +# # required "openid" scope. +# scope: ["openid", "profile", "email"] +# +# # Only verified email addresses are synchronized to the user profile by +# # default. Unverified emails may be allowed in case an identity provider +# # does not send the "email_verified: true" claim or email verification is +# # not required. +# email_verified_required: true +# +# # Provide custom key/value pairs which get sent to the identity provider's +# # authorization endpoint. +# extra_params: +# domain_hint: example.com +# +# # Only accept users whose email domain is part of the allowed_domains list. +# allowed_domains: +# - example.com +# +# # Only accept users whose email address is part of the allowed_users list. +# allowed_users: +# - alice@example.com +# +# # Only accept users which are members of at least one group in the +# # allowed_groups list. +# allowed_groups: +# - /headscale +# +# # Optional: PKCE (Proof Key for Code Exchange) configuration +# # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow +# # by preventing authorization code interception attacks +# # See https://datatracker.ietf.org/doc/html/rfc7636 +# pkce: +# # Enable or disable PKCE support (default: false) +# enabled: false +# +# # PKCE method to use: +# # - plain: Use plain code verifier +# # - S256: Use SHA256 hashed code verifier (default, recommended) +# method: S256 + +# Logtail configuration +# Logtail is Tailscales logging and auditing infrastructure, it allows the +# control panel to instruct tailscale nodes to log their activity to a remote +# server. To disable logging on the client side, please refer to: +# https://tailscale.com/kb/1011/log-mesh-traffic#opting-out-of-client-logging +logtail: + # Enable logtail for tailscale nodes of this Headscale instance. + # As there is currently no support for overriding the log server in Headscale, this is + # disabled by default. Enabling this will make your clients send logs to Tailscale Inc. + enabled: false + +# Enabling this option makes devices prefer a random port for WireGuard traffic over the +# default static port 41641. This option is intended as a workaround for some buggy +# firewall devices. See https://tailscale.com/kb/1181/firewalls/ for more information. +randomize_client_port: false + +# Taildrop configuration +# Taildrop is the file sharing feature of Tailscale, allowing nodes to send files to each other. +# https://tailscale.com/kb/1106/taildrop/ +taildrop: + # Enable or disable Taildrop for all nodes. + # When enabled, nodes can send files to other nodes owned by the same user. + # Tagged devices and cross-user transfers are not permitted by Tailscale clients. + enabled: true +# Advanced performance tuning parameters. +# The defaults are carefully chosen and should rarely need adjustment. +# Only modify these if you have identified a specific performance issue. +# +# tuning: +# # NodeStore write batching configuration. +# # The NodeStore batches write operations before rebuilding peer relationships, +# # which is computationally expensive. Batching reduces rebuild frequency. +# # +# # node_store_batch_size: 100 +# # node_store_batch_timeout: 500ms diff --git a/hscontrol/types/testdata/compat/example-v0.29.0.yaml b/hscontrol/types/testdata/compat/example-v0.29.0.yaml new file mode 100644 index 000000000..22b9f3496 --- /dev/null +++ b/hscontrol/types/testdata/compat/example-v0.29.0.yaml @@ -0,0 +1,494 @@ +--- +# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order: +# +# - `/etc/headscale` +# - `~/.headscale` +# - current working directory + +# The url clients will connect to. +# Typically this will be a domain like: +# +# https://myheadscale.example.com:443 +# +server_url: http://127.0.0.1:8080 + +# Address to listen to / bind to on the server +# +# For production: +# listen_addr: 0.0.0.0:8080 +listen_addr: 127.0.0.1:8080 + +# Address to listen to /metrics and /debug, you may want +# to keep this endpoint private to your internal network +# Use an empty value to disable the metrics listener. +metrics_listen_addr: 127.0.0.1:9090 + +# Address to listen for gRPC. +# gRPC is used for controlling a headscale server +# remotely with the CLI +# Note: Remote access _only_ works if you have +# valid certificates. +# +# For production: +# grpc_listen_addr: 0.0.0.0:50443 +grpc_listen_addr: 127.0.0.1:50443 + +# Allow the gRPC admin interface to run in INSECURE +# mode. This is not recommended as the traffic will +# be unencrypted. Only enable if you know what you +# are doing. +grpc_allow_insecure: false + +# CIDR(s) of reverse proxies (e.g. 127.0.0.1/32) whose +# True-Client-IP, X-Real-IP and X-Forwarded-For headers should +# be honoured. Empty (default) ignores those headers; setting +# this without a proxy in front lets clients spoof their logged +# source IP. +trusted_proxies: [] + +# The Noise section includes specific configuration for the +# TS2021 Noise protocol +noise: + # The Noise private key is used to encrypt the traffic between headscale and + # Tailscale clients when using the new Noise-based protocol. A missing key + # will be automatically generated. + private_key_path: /var/lib/headscale/noise_private.key + +# List of IP prefixes to allocate tailaddresses from. +# Each prefix consists of either an IPv4 or IPv6 address, +# and the associated prefix length, delimited by a slash. +# +# WARNING: These prefixes MUST be subsets of the standard Tailscale ranges: +# - IPv4: 100.64.0.0/10 (CGNAT range) +# - IPv6: fd7a:115c:a1e0::/48 (Tailscale ULA range) +# +# Using a SUBSET of these ranges is supported and useful if you want to +# limit IP allocation to a smaller block (e.g., 100.64.0.0/24). +# +# Using ranges OUTSIDE of CGNAT/ULA is NOT supported and will cause +# undefined behaviour. The Tailscale client has hard-coded assumptions +# about these ranges and will break in subtle, hard-to-debug ways. +# +# See: +# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33 +# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71 +prefixes: + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 + + # Strategy used for allocation of IPs to nodes, available options: + # - sequential (default): assigns the next free IP from the previous given + # IP. A best-effort approach is used and Headscale might leave holes in the + # IP range or fill up existing holes in the IP range. + # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand). + allocation: sequential + +# DERP is a relay system that Tailscale uses when a direct +# connection cannot be established. +# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp +# +# Headscale needs a list of DERP servers that can be presented to the clients. +derp: + server: + # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config + # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place + enabled: false + + # Region ID to use for the embedded DERP server. + # The local DERP prevails if the region ID collides with other region ID coming from + # the regular DERP config. + region_id: 999 + + # Region code and name are displayed in the Tailscale UI to identify a DERP region + region_code: "headscale" + region_name: "Headscale Embedded DERP" + + # Only allow clients associated with this server access + verify_clients: true + + # Listens over UDP at the configured address for STUN connections - to help with NAT traversal. + # When the embedded DERP server is enabled stun_listen_addr MUST be defined. + # + # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/ + stun_listen_addr: "0.0.0.0:3478" + + # Private key used to encrypt the traffic between headscale DERP and + # Tailscale clients. A missing key will be automatically generated. + private_key_path: /var/lib/headscale/derp_server_private.key + + # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically, + # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths + # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths + automatically_add_embedded_derp_region: true + + # For better connection stability (especially when using an Exit-Node and DNS is not working), + # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using: + ipv4: 198.51.100.1 + ipv6: 2001:db8::1 + + # List of externally available DERP maps encoded in JSON + urls: + - https://controlplane.tailscale.com/derpmap/default + + # Locally available DERP map files encoded in YAML + # + # This option is mostly interesting for people hosting their own DERP servers: + # https://tailscale.com/docs/reference/derp-servers/custom-derp-servers + # https://headscale.net/stable/ref/derp/ + # + # paths: + # - /etc/headscale/derp-example.yaml + paths: [] + + # If enabled, a worker will be set up to periodically + # refresh the given sources and update the derpmap + # will be set up. + auto_update_enabled: true + + # How often should we check for DERP updates? + update_frequency: 3h + +# Disables the automatic check for headscale updates on startup +disable_check_updates: false + +# Node lifecycle configuration. +node: + # Default key expiry for non-tagged nodes, regardless of registration method + # (auth key, CLI, web auth). Tagged nodes are exempt and never expire. + # + # This is the base default. OIDC can override this via oidc.expiry. + # If a client explicitly requests a specific expiry, the client value is used. + # + # Setting the value to "0" means no default expiry (nodes never expire unless + # explicitly expired via `headscale nodes expire`). + # + # Tailscale SaaS uses 180d; set to a positive duration to match that behaviour. + # + # Default: 0 (no default expiry) + expiry: 0 + + ephemeral: + # Time before an inactive ephemeral node is deleted. + inactivity_timeout: 30m + + # HA subnet router health probing. + # + # When HA routes exist (2+ nodes advertising the same prefix), headscale + # pings each HA node every probe_interval via the Noise channel. If a node + # fails to respond within probe_timeout it is marked unhealthy and the + # primary role moves to the next healthy node. A node that later responds + # is marked healthy again but does NOT reclaim primary (avoids flapping). + # + # Worst-case detection time is probe_interval + probe_timeout (15s default). + # No-op when no HA routes exist. Set probe_interval to 0 to disable. + routes: + ha: + # How often to ping HA subnet routers. Set to 0 to disable probing. + # Must be >= 2s when enabled. + probe_interval: 10s + + # How long to wait for a ping response before marking a node unhealthy. + # Must be >= 1s and less than probe_interval. + probe_timeout: 5s + +database: + # Database type. Available options: sqlite, postgres + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # All new development, testing and optimisations are done with SQLite in mind. + type: sqlite + + # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace". + debug: false + + # GORM configuration settings. + gorm: + # Enable prepared statements. + prepare_stmt: true + + # Enable parameterized queries. + parameterized_queries: true + + # Skip logging "record not found" errors. + skip_err_record_not_found: true + + # Threshold for slow queries in milliseconds. + slow_threshold: 1000 + + # SQLite config + sqlite: + path: /var/lib/headscale/db.sqlite + + # Enable WAL mode for SQLite. This is recommended for production environments. + # https://www.sqlite.org/wal.html + write_ahead_log: true + + # Maximum number of WAL file frames before the WAL file is automatically checkpointed. + # https://www.sqlite.org/c3ref/wal_autocheckpoint.html + # Set to 0 to disable automatic checkpointing. + wal_autocheckpoint: 1000 + + # # Postgres config + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # See database.type for more information. + # postgres: + # # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank. + # host: localhost + # port: 5432 + # name: headscale + # user: foo + # pass: bar + # max_open_conns: 10 + # max_idle_conns: 10 + # conn_max_idle_time_secs: 3600 + + # # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need + # # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1. + # ssl: false + +### TLS configuration +# +## Let's encrypt / ACME +# +# headscale supports automatically requesting and setting up +# TLS for a domain with Let's Encrypt. +# +# URL to ACME directory +acme_url: https://acme-v02.api.letsencrypt.org/directory + +# Email to register with ACME provider +acme_email: "" + +# Domain name to request a TLS certificate for: +tls_letsencrypt_hostname: "" + +# Path to store certificates and metadata needed by +# letsencrypt +# For production: +tls_letsencrypt_cache_dir: /var/lib/headscale/cache + +# Type of ACME challenge to use, currently supported types: +# HTTP-01 or TLS-ALPN-01 +# See: https://headscale.net/stable/ref/tls/ +tls_letsencrypt_challenge_type: HTTP-01 +# When HTTP-01 challenge is chosen, letsencrypt must set up a +# verification endpoint, and it will be listening on: +# :http = port 80 +tls_letsencrypt_listen: ":http" + +## Use already defined certificates: +tls_cert_path: "" +tls_key_path: "" + +log: + # Valid log levels: panic, fatal, error, warn, info, debug, trace + level: info + + # Output formatting for logs: text or json + format: text + +## Policy +# Headscale supports a wide range of Tailscale policy features such as ACLs and +# Grants. Please have a look at their docs to better understand the concepts: +# ACLs: https://tailscale.com/docs/features/access-control/acls +# Grants: https://tailscale.com/docs/features/access-control/grants +policy: + # The mode can be "file" or "database" that defines + # where the policies are stored and read from. + mode: file + # If the mode is set to "file", the path to a HuJSON file containing policies. + path: "" + +## DNS +# +# headscale supports Tailscale's DNS configuration and MagicDNS. +# Please have a look to their docs to better understand the concepts: +# +# - https://tailscale.com/docs/features/magicdns +# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns +# +# Please note that for the DNS configuration to have any effect, +# clients must have the `--accept-dns=true` option enabled. This is the +# default for the Tailscale client. This option is enabled by default +# in the Tailscale client. +# +# Setting _any_ of the configuration and `--accept-dns=true` on the +# clients will integrate with the DNS manager on the client or +# overwrite /etc/resolv.conf. +# https://tailscale.com/docs/reference/faq/dns-resolv-conf +# +# If you want stop Headscale from managing the DNS configuration +# all the fields under `dns` should be set to empty values. +dns: + # Whether to use MagicDNS + magic_dns: true + + # Defines the base domain to create the hostnames for MagicDNS. + # This domain _must_ be different from the server_url domain. + # `base_domain` must be a FQDN, without the trailing dot. + # The FQDN of the hosts will be + # `hostname.base_domain` (e.g., _myhost.example.com_). + base_domain: example.com + + # Whether to use the local DNS settings of a node or override the local DNS + # settings (default) and force the use of Headscale's DNS configuration. + override_local_dns: true + + # List of DNS servers to expose to clients. + nameservers: + global: + - 1.1.1.1 + - 1.0.0.1 + - 2606:4700:4700::1111 + - 2606:4700:4700::1001 + + # NextDNS (see https://tailscale.com/docs/integrations/nextdns). + # "abc123" is example NextDNS ID, replace with yours. + # - https://dns.nextdns.io/abc123 + + # Split DNS (see https://tailscale.com/docs/reference/dns-in-tailscale#restricted-nameservers), + # a map of domains and which DNS server to use for each. + split: {} + # foo.bar.com: + # - 1.1.1.1 + # darp.headscale.net: + # - 1.1.1.1 + # - 8.8.8.8 + + # Set custom DNS search domains. With MagicDNS enabled, + # your tailnet base_domain is always the first search domain. + search_domains: [] + + # Extra DNS records + # so far only A and AAAA records are supported (on the tailscale side) + # See: https://headscale.net/stable/ref/dns/ + extra_records: [] + # - name: "grafana.myvpn.example.com" + # type: "A" + # value: "100.64.0.3" + # + # # you can also put it in one line + # - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" } + # + # Alternatively, extra DNS records can be loaded from a JSON file. + # Headscale processes this file on each change. + # extra_records_path: /var/lib/headscale/extra-records.json + +# Unix socket used for the CLI to connect without authentication +# Note: for production you will want to set this to something like: +unix_socket: /var/run/headscale/headscale.sock +unix_socket_permission: "0770" + +# OpenID Connect +# https://headscale.net/stable/ref/oidc/ +# oidc: +# # Block startup until the identity provider is available and healthy. +# only_start_if_oidc_is_available: true +# +# # OpenID Connect Issuer URL from the identity provider +# issuer: "https://your-oidc.issuer.com/path" +# +# # Client ID from the identity provider +# client_id: "your-oidc-client-id" +# +# # Client secret generated by the identity provider +# # Note: client_secret and client_secret_path are mutually exclusive. +# client_secret: "your-oidc-client-secret" +# # Alternatively, set `client_secret_path` to read the secret from the file. +# # It resolves environment variables, making integration to systemd's +# # `LoadCredential` straightforward: +# client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret" +# +# # Use the expiry from the token received from OpenID when the user logged +# # in. This will typically lead to frequent need to reauthenticate and should +# # only be enabled if you know what you are doing. +# # Note: enabling this will cause `node.expiry` to be ignored for +# # OIDC-authenticated nodes. +# use_expiry_from_token: false +# +# # The OIDC scopes to use, defaults to "openid", "profile" and "email". +# # Custom scopes can be configured as needed, be sure to always include the +# # required "openid" scope. +# scope: ["openid", "profile", "email"] +# +# # Only verified email addresses are synchronized to the user profile by +# # default. Unverified emails may be allowed in case an identity provider +# # does not send the "email_verified: true" claim or email verification is +# # not required. +# email_verified_required: true +# +# # Provide custom key/value pairs which get sent to the identity provider's +# # authorization endpoint. +# extra_params: +# domain_hint: example.com +# +# # Only accept users whose email domain is part of the allowed_domains list. +# allowed_domains: +# - example.com +# +# # Only accept users whose email address is part of the allowed_users list. +# allowed_users: +# - alice@example.com +# +# # Only accept users which are members of at least one group in the +# # allowed_groups list. +# allowed_groups: +# - /headscale +# +# # Optional: PKCE (Proof Key for Code Exchange) configuration +# # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow +# # by preventing authorization code interception attacks +# # See https://datatracker.ietf.org/doc/html/rfc7636 +# pkce: +# # Enable or disable PKCE support (default: false) +# enabled: false +# +# # PKCE method to use: +# # - plain: Use plain code verifier +# # - S256: Use SHA256 hashed code verifier (default, recommended) +# method: S256 + +# Logtail configuration +# Logtail is Tailscales logging and auditing infrastructure, it allows the +# control panel to instruct tailscale nodes to log their activity to a remote +# server. To disable logging on the client side, please refer to: +# https://tailscale.com/docs/features/logging#opt-out-of-client-logging +logtail: + # Enable logtail for tailscale nodes of this Headscale instance. + # As there is currently no support for overriding the log server in Headscale, this is + # disabled by default. Enabling this will make your clients send logs to Tailscale Inc. + enabled: false + +# Taildrop configuration +# Taildrop is the file sharing feature of Tailscale, allowing nodes to +# send files to each other. +# https://tailscale.com/docs/features/taildrop +taildrop: + # Enable or disable Taildrop tailnet-wide. When disabled, headscale + # withholds `https://tailscale.com/cap/file-sharing` from every + # node's CapMap. + enabled: true + +# Default node auto-update behaviour. When enabled, every node's +# CapMap carries `default-auto-update: [true]` so clients that have +# not made a local opt-in / opt-out choice run auto-updates by +# default. Setting it back to false flips the default for future +# clients; clients that already stored the value locally keep their +# choice. +auto_update: + enabled: false +# Advanced performance tuning parameters. +# The defaults are carefully chosen and should rarely need adjustment. +# Only modify these if you have identified a specific performance issue. +# +# tuning: +# # Maximum number of pending registration entries in the auth cache. +# # Oldest entries are evicted when the cap is reached. +# # +# # register_cache_max_entries: 1024 +# +# # NodeStore write batching configuration. +# # The NodeStore batches write operations before rebuilding peer relationships, +# # which is computationally expensive. Batching reduces rebuild frequency. +# # +# # node_store_batch_size: 100 +# # node_store_batch_timeout: 500ms diff --git a/hscontrol/types/testdata/compat/example-v0.29.7.yaml b/hscontrol/types/testdata/compat/example-v0.29.7.yaml new file mode 100644 index 000000000..cfb06f70c --- /dev/null +++ b/hscontrol/types/testdata/compat/example-v0.29.7.yaml @@ -0,0 +1,497 @@ +--- +# headscale will look for a configuration file named `config.yaml` (or `config.json`) in the following order: +# +# - `/etc/headscale` +# - `~/.headscale` +# - current working directory + +# The url clients will connect to. +# Typically this will be a domain like: +# +# https://myheadscale.example.com:443 +# +server_url: http://127.0.0.1:8080 + +# Address to listen to / bind to on the server +# +# For production: +# listen_addr: 0.0.0.0:8080 +listen_addr: 127.0.0.1:8080 + +# Address to listen to /metrics and /debug, you may want +# to keep this endpoint private to your internal network +# Use an empty value to disable the metrics listener. +metrics_listen_addr: 127.0.0.1:9090 + +# Address to listen for gRPC. +# gRPC is used for controlling a headscale server +# remotely with the CLI +# Note: Remote access _only_ works if you have +# valid certificates. +# +# For production: +# grpc_listen_addr: 0.0.0.0:50443 +grpc_listen_addr: 127.0.0.1:50443 + +# Allow the gRPC admin interface to run in INSECURE +# mode. This is not recommended as the traffic will +# be unencrypted. Only enable if you know what you +# are doing. +grpc_allow_insecure: false + +# CIDR(s) of reverse proxies (e.g. 127.0.0.1/32) whose +# True-Client-IP, X-Real-IP and X-Forwarded-For headers should +# be honoured. Empty (default) ignores those headers; setting +# this without a proxy in front lets clients spoof their logged +# source IP. +trusted_proxies: [] + +# The Noise section includes specific configuration for the +# TS2021 Noise protocol +noise: + # The Noise private key is used to encrypt the traffic between headscale and + # Tailscale clients when using the new Noise-based protocol. A missing key + # will be automatically generated. + private_key_path: /var/lib/headscale/noise_private.key + +# List of IP prefixes to allocate tailaddresses from. +# Each prefix consists of either an IPv4 or IPv6 address, +# and the associated prefix length, delimited by a slash. +# +# WARNING: These prefixes MUST be subsets of the standard Tailscale ranges: +# - IPv4: 100.64.0.0/10 (CGNAT range) +# - IPv6: fd7a:115c:a1e0::/48 (Tailscale ULA range) +# +# Using a SUBSET of these ranges is supported and useful if you want to +# limit IP allocation to a smaller block (e.g., 100.64.0.0/24). +# +# Using ranges OUTSIDE of CGNAT/ULA is NOT supported and will cause +# undefined behaviour. The Tailscale client has hard-coded assumptions +# about these ranges and will break in subtle, hard-to-debug ways. +# +# See: +# IPv4: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#L33 +# IPv6: https://github.com/tailscale/tailscale/blob/22ebb25e833264f58d7c3f534a8b166894a89536/net/tsaddr/tsaddr.go#LL81C52-L81C71 +prefixes: + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 + + # Strategy used for allocation of IPs to nodes, available options: + # - sequential (default): assigns the next free IP from the previous given + # IP. A best-effort approach is used and Headscale might leave holes in the + # IP range or fill up existing holes in the IP range. + # - random: assigns the next free IP from a pseudo-random IP generator (crypto/rand). + allocation: sequential + +# DERP is a relay system that Tailscale uses when a direct +# connection cannot be established. +# https://tailscale.com/blog/how-tailscale-works/#encrypted-tcp-relays-derp +# +# Headscale needs a list of DERP servers that can be presented to the clients. +derp: + server: + # If enabled, runs the embedded DERP server and merges it into the rest of the DERP config + # The Headscale server_url defined above MUST be using https, DERP requires TLS to be in place + enabled: false + + # Region ID to use for the embedded DERP server. + # The local DERP prevails if the region ID collides with other region ID coming from + # the regular DERP config. + region_id: 999 + + # Region code and name are displayed in the Tailscale UI to identify a DERP region + region_code: "headscale" + region_name: "Headscale Embedded DERP" + + # Only allow clients associated with this server access + verify_clients: true + + # Listens over UDP at the configured address for STUN connections - to help with NAT traversal. + # When the embedded DERP server is enabled stun_listen_addr MUST be defined. + # + # For more details on how this works, check this great article: https://tailscale.com/blog/how-tailscale-works/ + stun_listen_addr: "0.0.0.0:3478" + + # Private key used to encrypt the traffic between headscale DERP and + # Tailscale clients. A missing key will be automatically generated. + private_key_path: /var/lib/headscale/derp_server_private.key + + # This flag can be used, so the DERP map entry for the embedded DERP server is not written automatically, + # it enables the creation of your very own DERP map entry using a locally available file with the parameter DERP.paths + # If you enable the DERP server and set this to false, it is required to add the DERP server to the DERP map using DERP.paths + automatically_add_embedded_derp_region: true + + # For better connection stability (especially when using an Exit-Node and DNS is not working), + # it is possible to optionally add the public IPv4 and IPv6 address to the Derp-Map using: + ipv4: 198.51.100.1 + ipv6: 2001:db8::1 + + # List of externally available DERP maps encoded in JSON + urls: + - https://controlplane.tailscale.com/derpmap/default + + # Locally available DERP map files encoded in YAML + # + # This option is mostly interesting for people hosting their own DERP servers: + # https://tailscale.com/docs/reference/derp-servers/custom-derp-servers + # https://headscale.net/stable/ref/derp/ + # + # paths: + # - /etc/headscale/derp-example.yaml + paths: [] + + # If enabled, a worker will be set up to periodically + # refresh the given sources and update the derpmap + # will be set up. + auto_update_enabled: true + + # How often should we check for DERP updates? + update_frequency: 3h + +# Disables the automatic check for headscale updates on startup +disable_check_updates: false + +# Node lifecycle configuration. +node: + # Default key expiry for non-tagged nodes, regardless of registration method + # (auth key, CLI, web auth). Tagged nodes are exempt and never expire. + # + # This is the base default. OIDC can override this via oidc.expiry. + # If a client explicitly requests a specific expiry, the client value is used. + # + # Setting the value to "0" means no default expiry (nodes never expire unless + # explicitly expired via `headscale nodes expire`). + # + # Tailscale SaaS uses 180d; set to a positive duration to match that behaviour. + # + # Default: 0 (no default expiry) + expiry: 0 + + ephemeral: + # Time before an inactive ephemeral node is deleted. + inactivity_timeout: 30m + + # HA subnet router health probing. + # + # When HA routes exist (2+ nodes advertising the same prefix), headscale + # pings each HA node every probe_interval via the Noise channel. If a node + # fails to respond within probe_timeout it is marked unhealthy and the + # primary role moves to the next healthy node. A node that later responds + # is marked healthy again but does NOT reclaim primary (avoids flapping). + # + # Worst-case detection time is probe_interval + probe_timeout (15s default). + # No-op when no HA routes exist. Set probe_interval to 0 to disable. + routes: + ha: + # How often to ping HA subnet routers. Set to 0 to disable probing. + # Must be >= 2s when enabled. + probe_interval: 10s + + # How long to wait for a ping response before marking a node unhealthy. + # Must be >= 1s and less than probe_interval. + probe_timeout: 5s + +database: + # Database type. Available options: sqlite, postgres + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # All new development, testing and optimisations are done with SQLite in mind. + type: sqlite + + # Enable debug mode. This setting requires the log.level to be set to "debug" or "trace". + debug: false + + # GORM configuration settings. + gorm: + # Enable prepared statements. + prepare_stmt: true + + # Enable parameterized queries. + parameterized_queries: true + + # Skip logging "record not found" errors. + skip_err_record_not_found: true + + # Threshold for slow queries in milliseconds. + slow_threshold: 1000 + + # SQLite config + sqlite: + path: /var/lib/headscale/db.sqlite + + # Enable WAL mode for SQLite. This is recommended for production environments. + # https://www.sqlite.org/wal.html + write_ahead_log: true + + # Maximum number of WAL file frames before the WAL file is automatically checkpointed. + # https://www.sqlite.org/c3ref/wal_autocheckpoint.html + # Set to 0 to disable automatic checkpointing. + wal_autocheckpoint: 1000 + + # # Postgres config + # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons. + # See database.type for more information. + # postgres: + # # If using a Unix socket to connect to Postgres, set the socket path in the 'host' field and leave 'port' blank. + # host: localhost + # port: 5432 + # name: headscale + # user: foo + # pass: bar + # max_open_conns: 10 + # max_idle_conns: 10 + # conn_max_idle_time_secs: 3600 + + # # If other 'sslmode' is required instead of 'require(true)' and 'disabled(false)', set the 'sslmode' you need + # # in the 'ssl' field. Refers to https://www.postgresql.org/docs/current/libpq-ssl.html Table 34.1. + # ssl: false + +### TLS configuration +# +## Let's encrypt / ACME +# +# headscale supports automatically requesting and setting up +# TLS for a domain with Let's Encrypt. +# +# URL to ACME directory +acme_url: https://acme-v02.api.letsencrypt.org/directory + +# Email to register with ACME provider +acme_email: "" + +# Domain name to request a TLS certificate for: +tls_letsencrypt_hostname: "" + +# Path to store certificates and metadata needed by +# letsencrypt +# For production: +tls_letsencrypt_cache_dir: /var/lib/headscale/cache + +# Type of ACME challenge to use, currently supported types: +# HTTP-01 or TLS-ALPN-01 +# See: https://headscale.net/stable/ref/tls/ +tls_letsencrypt_challenge_type: HTTP-01 +# When HTTP-01 challenge is chosen, letsencrypt must set up a +# verification endpoint, and it will be listening on: +# :http = port 80 +tls_letsencrypt_listen: ":http" + +## Use already defined certificates: +tls_cert_path: "" +tls_key_path: "" + +log: + # Valid log levels: panic, fatal, error, warn, info, debug, trace + level: info + + # Output formatting for logs: text or json + format: text + +## Policy +# Headscale supports a wide range of Tailscale policy features such as ACLs and +# Grants. Please have a look at their docs to better understand the concepts: +# ACLs: https://tailscale.com/docs/features/access-control/acls +# Grants: https://tailscale.com/docs/features/access-control/grants +policy: + # The mode can be "file" or "database" that defines + # where the policies are stored and read from. + mode: file + # If the mode is set to "file", the path to a HuJSON file containing policies. + path: "" + +## DNS +# +# headscale supports Tailscale's DNS configuration and MagicDNS. +# Please have a look to their docs to better understand the concepts: +# +# - https://tailscale.com/docs/features/magicdns +# - https://tailscale.com/blog/2021-09-private-dns-with-magicdns +# +# Please note that for the DNS configuration to have any effect, +# clients must have the `--accept-dns=true` option enabled. This is the +# default for the Tailscale client. This option is enabled by default +# in the Tailscale client. +# +# Setting _any_ of the configuration and `--accept-dns=true` on the +# clients will integrate with the DNS manager on the client or +# overwrite /etc/resolv.conf. +# https://tailscale.com/docs/reference/faq/dns-resolv-conf +# +# If you want stop Headscale from managing the DNS configuration +# all the fields under `dns` should be set to empty values. +dns: + # Whether to use MagicDNS + magic_dns: true + + # Defines the base domain to create the hostnames for MagicDNS. + # This domain _must_ be different from the server_url domain. + # `base_domain` must be a FQDN, without the trailing dot. + # The FQDN of the hosts will be + # `hostname.base_domain` (e.g., _myhost.example.com_). + base_domain: example.com + + # Whether to use the local DNS settings of a node or override the local DNS + # settings (default) and force the use of Headscale's DNS configuration. + override_local_dns: true + + # List of DNS servers to expose to clients. + nameservers: + global: + - 1.1.1.1 + - 1.0.0.1 + - 2606:4700:4700::1111 + - 2606:4700:4700::1001 + + # NextDNS (see https://tailscale.com/docs/integrations/nextdns). + # "abc123" is example NextDNS ID, replace with yours. + # - https://dns.nextdns.io/abc123 + + # Split DNS (see https://tailscale.com/docs/reference/dns-in-tailscale#restricted-nameservers), + # a map of domains and which DNS server to use for each. + split: {} + # foo.bar.com: + # - 1.1.1.1 + # darp.headscale.net: + # - 1.1.1.1 + # - 8.8.8.8 + + # Set custom DNS search domains. With MagicDNS enabled, + # your tailnet base_domain is always the first search domain. + search_domains: [] + + # Extra DNS records + # so far only A and AAAA records are supported (on the tailscale side) + # See: https://headscale.net/stable/ref/dns/ + extra_records: [] + # - name: "grafana.myvpn.example.com" + # type: "A" + # value: "100.64.0.3" + # + # # you can also put it in one line + # - { name: "prometheus.myvpn.example.com", type: "A", value: "100.64.0.3" } + # + # Alternatively, extra DNS records can be loaded from a JSON file. + # Headscale processes this file on each change. + # extra_records_path: /var/lib/headscale/extra-records.json + +# Unix socket used for the CLI to connect without authentication +# Note: for production you will want to set this to something like: +unix_socket: /var/run/headscale/headscale.sock +unix_socket_permission: "0770" + +# OpenID Connect +# https://headscale.net/stable/ref/oidc/ +# oidc: +# # Block startup until the identity provider is available and healthy. +# only_start_if_oidc_is_available: true +# +# # OpenID Connect Issuer URL from the identity provider +# issuer: "https://your-oidc.issuer.com/path" +# +# # Client ID from the identity provider +# client_id: "your-oidc-client-id" +# +# # Client secret generated by the identity provider +# # Note: client_secret and client_secret_path are mutually exclusive. +# client_secret: "your-oidc-client-secret" +# # Alternatively, set `client_secret_path` to read the secret from the file. +# # It resolves environment variables, making integration to systemd's +# # `LoadCredential` straightforward: +# client_secret_path: "${CREDENTIALS_DIRECTORY}/oidc_client_secret" +# +# # Use the expiry from the token received from OpenID when the user logged +# # in. This will typically lead to frequent need to reauthenticate and should +# # only be enabled if you know what you are doing. +# # Note: enabling this will cause `node.expiry` to be ignored for +# # OIDC-authenticated nodes. +# use_expiry_from_token: false +# +# # The OIDC scopes to use, defaults to "openid", "profile" and "email". +# # Custom scopes can be configured as needed, be sure to always include the +# # required "openid" scope. +# scope: ["openid", "profile", "email"] +# +# # Only verified email addresses are synchronized to the user profile by +# # default. Unverified emails may be allowed in case an identity provider +# # does not send the "email_verified: true" claim or email verification is +# # not required. +# email_verified_required: true +# +# # Provide custom key/value pairs which get sent to the identity provider's +# # authorization endpoint. +# extra_params: +# domain_hint: example.com +# +# # Only accept users whose email domain is part of the allowed_domains list. +# allowed_domains: +# - example.com +# +# # Only accept users whose email address is part of the allowed_users list. +# allowed_users: +# - alice@example.com +# +# # Only accept users which are members of at least one group in the +# # allowed_groups list. +# allowed_groups: +# - /headscale +# +# # Optional: PKCE (Proof Key for Code Exchange) configuration +# # PKCE adds an additional layer of security to the OAuth 2.0 authorization code flow +# # by preventing authorization code interception attacks +# # See https://datatracker.ietf.org/doc/html/rfc7636 +# pkce: +# # Enable or disable PKCE support (default: false) +# enabled: false +# +# # PKCE method to use: +# # - plain: Use plain code verifier +# # - S256: Use SHA256 hashed code verifier (default, recommended) +# method: S256 + +# Logtail configuration +# Logtail is Tailscales logging and auditing infrastructure, it allows the +# control panel to instruct tailscale nodes to log their activity to a remote +# server. To disable logging on the client side, please refer to: +# https://tailscale.com/docs/features/logging#opt-out-of-client-logging +logtail: + # Enable logtail for tailscale nodes of this Headscale instance. + # As there is currently no support for overriding the log server in Headscale, this is + # disabled by default. Enabling this will make your clients send logs to Tailscale Inc. + enabled: false + +# Taildrop configuration +# Taildrop is the file sharing feature of Tailscale, allowing nodes to +# send files to each other. +# https://tailscale.com/docs/features/taildrop +taildrop: + # Enable or disable Taildrop tailnet-wide. When disabled, headscale + # withholds `https://tailscale.com/cap/file-sharing` from every + # node's CapMap. + enabled: true + +# Default node auto-update behaviour. When enabled, every node's +# CapMap carries `default-auto-update: [true]` so clients that have +# not made a local opt-in / opt-out choice run auto-updates by +# default. Setting it back to false flips the default for future +# clients; clients that already stored the value locally keep their +# choice. +auto_update: + enabled: false +# Advanced performance tuning parameters. +# The defaults are carefully chosen and should rarely need adjustment. +# Only modify these if you have identified a specific performance issue. +# +# tuning: +# # Maximum number of pending registration entries in the auth cache. +# # At capacity, new registrations retry without displacing pending approvals. +# # SSH checks can use 64 additional reserved entries. Each registration +# # retains at most 64 KiB of serialized data, so the default registration +# # payload budget is 64 MiB plus record overhead. +# # +# # register_cache_max_entries: 1024 +# +# # NodeStore write batching configuration. +# # The NodeStore batches write operations before rebuilding peer relationships, +# # which is computationally expensive. Batching reduces rebuild frequency. +# # +# # node_store_batch_size: 100 +# # node_store_batch_timeout: 500ms diff --git a/hscontrol/types/testdata/compat/file-everything.env b/hscontrol/types/testdata/compat/file-everything.env new file mode 100644 index 000000000..e664c7012 --- /dev/null +++ b/hscontrol/types/testdata/compat/file-everything.env @@ -0,0 +1 @@ +COMPAT_SECRETS=testdata/compat diff --git a/hscontrol/types/testdata/compat/file-everything.yaml b/hscontrol/types/testdata/compat/file-everything.yaml new file mode 100644 index 000000000..6138ff130 --- /dev/null +++ b/hscontrol/types/testdata/compat/file-everything.yaml @@ -0,0 +1,143 @@ +# Every key the loader reads, set to a valid non-default value. +server_url: https://headscale.example.com +listen_addr: 0.0.0.0:8443 +metrics_listen_addr: 127.0.0.1:9091 +trusted_proxies: [10.0.0.0/8, 192.168.0.0/16] +disable_check_updates: true +unix_socket: /run/headscale/headscale.sock +unix_socket_permission: "0700" + +noise: + private_key_path: ./noise_private.key + +prefixes: + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 + allocation: random + +derp: + server: + enabled: true + region_id: 900 + region_code: hs + region_name: Headscale Embedded DERP + verify_clients: false + stun_listen_addr: 0.0.0.0:3479 + private_key_path: ./derp_server_private.key + automatically_add_embedded_derp_region: false + ipv4: 198.51.100.1 + ipv6: 2001:db8::1 + urls: + - https://controlplane.tailscale.com/derpmap/default + - https://derp.example.com/map.json + paths: + - /etc/headscale/derp.yaml + auto_update_enabled: false + update_frequency: 1h + +node: + expiry: 90d + ephemeral: + inactivity_timeout: 45m + routes: + ha: + probe_interval: 20s + probe_timeout: 7s + +preauth_keys: + revoked_retention: 72h + +database: + type: postgres + debug: true + gorm: + parameterized_queries: true + skip_err_record_not_found: false + slow_threshold: 2000 + postgres: + host: db.example.com + port: 5433 + name: headscale + user: headscale + pass: marker-postgres-pass + max_open_conns: 20 + max_idle_conns: 5 + conn_max_idle_time_secs: 1800 + ssl: true + +tls: + acme: + hostname: headscale.example.com + challenge_type: TLS-ALPN-01 + http_listen: :8081 + url: https://acme-staging-v02.api.letsencrypt.org/directory + email: admin@example.com + cache_dir: ./acme-cache + +log: + format: json + level: debug + +policy: + mode: database + +dns: + magic_dns: true + base_domain: tailnet.example.net + override_local_dns: true + nameservers: + global: + - 1.1.1.1 + - https://dns.nextdns.io/abc123 + split: + Corp.Example.COM: + - 10.0.0.1 + search_domains: [corp.example.com] + extra_records: + - name: grafana.tailnet.example.net + type: A + value: 100.64.0.3 + challenge: + propagation_timeout: 3m + resolvers: [9.9.9.9] + +oidc: + only_start_if_oidc_is_available: false + issuer: https://idp.example.com + client_id: headscale + # os.ExpandEnv, then read relative to the test's working directory. + client_secret_path: ${COMPAT_SECRETS}/oidc-secret.txt + scope: [openid, profile, email, groups] + extra_params: + Login_Hint: file + allowed_domains: [example.com] + allowed_users: [alice@example.com] + allowed_groups: [/headscale] + email_verified_required: false + use_expiry_from_token: true + pkce: + enabled: true + method: plain + +logtail: + enabled: true +taildrop: + enabled: false +auto_update: + enabled: true + +cli: + address: headscale.example.com:443 + api_key: marker-cli-api-key + timeout: 15s + insecure: true + +tuning: + notifier_send_timeout: 1s + batch_change_delay: 500ms + node_mapsession_buffered_chan_size: 50 + batcher_workers: 4096 + register_cache_expiration: 20m + register_cache_max_entries: 2000 + node_store_batch_size: 50 + node_store_batch_timeout: 250ms diff --git a/hscontrol/types/testdata/compat/hsic-default.env b/hscontrol/types/testdata/compat/hsic-default.env new file mode 100644 index 000000000..a27db16f5 --- /dev/null +++ b/hscontrol/types/testdata/compat/hsic-default.env @@ -0,0 +1,32 @@ +HEADSCALE_LOG_LEVEL=trace +HEADSCALE_POLICY_PATH= +HEADSCALE_DATABASE_TYPE=sqlite +HEADSCALE_DATABASE_SQLITE_PATH=/tmp/integration_test_db.sqlite3 +HEADSCALE_DATABASE_DEBUG=0 +HEADSCALE_DATABASE_GORM_SLOW_THRESHOLD=1 +HEADSCALE_EPHEMERAL_NODE_INACTIVITY_TIMEOUT=30m +HEADSCALE_PREFIXES_V4=100.64.0.0/10 +HEADSCALE_PREFIXES_V6=fd7a:115c:a1e0::/48 +HEADSCALE_DNS_BASE_DOMAIN=headscale.net +HEADSCALE_DNS_MAGIC_DNS=true +HEADSCALE_DNS_OVERRIDE_LOCAL_DNS=false +HEADSCALE_DNS_NAMESERVERS_GLOBAL=127.0.0.11 1.1.1.1 +HEADSCALE_PRIVATE_KEY_PATH=/tmp/private.key +HEADSCALE_NOISE_PRIVATE_KEY_PATH=/tmp/noise_private.key +HEADSCALE_METRICS_LISTEN_ADDR=0.0.0.0:9090 +HEADSCALE_DEBUG_PORT=40000 +HEADSCALE_DERP_URLS= +HEADSCALE_DERP_AUTO_UPDATE_ENABLED=false +HEADSCALE_DERP_UPDATE_FREQUENCY=1m +HEADSCALE_DERP_SERVER_ENABLED=true +HEADSCALE_DERP_SERVER_REGION_ID=999 +HEADSCALE_DERP_SERVER_REGION_CODE=headscale +HEADSCALE_DERP_SERVER_REGION_NAME=Headscale Embedded DERP +HEADSCALE_DERP_SERVER_STUN_LISTEN_ADDR=0.0.0.0:3478 +HEADSCALE_DERP_SERVER_PRIVATE_KEY_PATH=/tmp/derp.key +DERP_DEBUG_LOGS=true +DERP_PROBER_DEBUG_LOGS=true +HEADSCALE_PREFIXES_ALLOCATION=sequential +# hsic.go sets these per container, outside DefaultConfigEnv. +HEADSCALE_SERVER_URL=http://hs-compat:8080 +HEADSCALE_LISTEN_ADDR=0.0.0.0:8080 diff --git a/hscontrol/types/testdata/compat/hsic-default.yaml b/hscontrol/types/testdata/compat/hsic-default.yaml new file mode 100644 index 000000000..3b65c7958 --- /dev/null +++ b/hscontrol/types/testdata/compat/hsic-default.yaml @@ -0,0 +1,3 @@ +private_key_path: /tmp/private.key +noise: + private_key_path: /tmp/noise_private.key diff --git a/hscontrol/types/testdata/compat/hsic-postgres.env b/hscontrol/types/testdata/compat/hsic-postgres.env new file mode 100644 index 000000000..ad1d2df0c --- /dev/null +++ b/hscontrol/types/testdata/compat/hsic-postgres.env @@ -0,0 +1,36 @@ +HEADSCALE_LOG_LEVEL=trace +HEADSCALE_POLICY_PATH= +HEADSCALE_DATABASE_DEBUG=0 +HEADSCALE_DATABASE_GORM_SLOW_THRESHOLD=1 +HEADSCALE_EPHEMERAL_NODE_INACTIVITY_TIMEOUT=30m +HEADSCALE_PREFIXES_V4=100.64.0.0/10 +HEADSCALE_PREFIXES_V6=fd7a:115c:a1e0::/48 +HEADSCALE_DNS_BASE_DOMAIN=headscale.net +HEADSCALE_DNS_MAGIC_DNS=true +HEADSCALE_DNS_OVERRIDE_LOCAL_DNS=false +HEADSCALE_DNS_NAMESERVERS_GLOBAL=127.0.0.11 1.1.1.1 +HEADSCALE_PRIVATE_KEY_PATH=/tmp/private.key +HEADSCALE_NOISE_PRIVATE_KEY_PATH=/tmp/noise_private.key +HEADSCALE_METRICS_LISTEN_ADDR=0.0.0.0:9090 +HEADSCALE_DEBUG_PORT=40000 +HEADSCALE_DERP_URLS= +HEADSCALE_DERP_AUTO_UPDATE_ENABLED=false +HEADSCALE_DERP_UPDATE_FREQUENCY=1m +HEADSCALE_DERP_SERVER_ENABLED=true +HEADSCALE_DERP_SERVER_REGION_ID=999 +HEADSCALE_DERP_SERVER_REGION_CODE=headscale +HEADSCALE_DERP_SERVER_REGION_NAME=Headscale Embedded DERP +HEADSCALE_DERP_SERVER_STUN_LISTEN_ADDR=0.0.0.0:3478 +HEADSCALE_DERP_SERVER_PRIVATE_KEY_PATH=/tmp/derp.key +DERP_DEBUG_LOGS=true +DERP_PROBER_DEBUG_LOGS=true +HEADSCALE_PREFIXES_ALLOCATION=sequential +# hsic.go sets these per container, outside DefaultConfigEnv. +HEADSCALE_SERVER_URL=http://hs-compat:8080 +HEADSCALE_LISTEN_ADDR=0.0.0.0:8080 +# hsic.WithPostgres overrides. +HEADSCALE_DATABASE_TYPE=postgres +HEADSCALE_DATABASE_POSTGRES_HOST=postgres-compat +HEADSCALE_DATABASE_POSTGRES_USER=headscale +HEADSCALE_DATABASE_POSTGRES_PASS=headscale +HEADSCALE_DATABASE_POSTGRES_NAME=headscale diff --git a/hscontrol/types/testdata/compat/hsic-postgres.yaml b/hscontrol/types/testdata/compat/hsic-postgres.yaml new file mode 100644 index 000000000..3b65c7958 --- /dev/null +++ b/hscontrol/types/testdata/compat/hsic-postgres.yaml @@ -0,0 +1,3 @@ +private_key_path: /tmp/private.key +noise: + private_key_path: /tmp/noise_private.key diff --git a/hscontrol/types/testdata/compat/nixos-cli.yaml b/hscontrol/types/testdata/compat/nixos-cli.yaml new file mode 100644 index 000000000..8cf37ea9a --- /dev/null +++ b/hscontrol/types/testdata/compat/nixos-cli.yaml @@ -0,0 +1,4 @@ +%YAML 1.1 +--- +disable_check_updates: true +unix_socket: /run/headscale/headscale.sock diff --git a/hscontrol/types/testdata/compat/nixos-example.yaml b/hscontrol/types/testdata/compat/nixos-example.yaml new file mode 100644 index 000000000..e19bd26aa --- /dev/null +++ b/hscontrol/types/testdata/compat/nixos-example.yaml @@ -0,0 +1,78 @@ +%YAML 1.1 +--- +database: + postgres: + host: null + name: null + password_file: null + port: null + user: null + sqlite: + path: /var/lib/headscale/db.sqlite + write_ahead_log: true + type: sqlite +derp: + auto_update_enabled: true + paths: [] + server: + private_key_path: /var/lib/headscale/derp_server_private.key + update_frequency: 24h + urls: + - https://controlplane.tailscale.com/derpmap/default +disable_check_updates: true +dns: + base_domain: tailnet.example.com + certificates: + enabled: false + zone: '' + challenge: + provider: null + extra_records: null + magic_dns: true + nameservers: + global: + - 1.1.1.1 + - 8.8.8.8 + split: {} + override_local_dns: true + search_domains: [] +listen_addr: 0.0.0.0:8080 +log: + format: text + level: info +node: + ephemeral: + inactivity_timeout: 30m + expiry: '0' +noise: + private_key_path: /var/lib/headscale/noise_private.key +oidc: + allowed_domains: [] + allowed_users: [] + client_id: '' + client_secret_path: null + extra_params: {} + issuer: '' + pkce: + enabled: false + method: S256 + scope: + - openid + - profile + - email +policy: + mode: file + path: /var/lib/headscale/policy.hujson +prefixes: + allocation: sequential + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 +server_url: https://headscale.example.com +tls: + acme: + challenge_type: null + hostname: '' + http_listen: null + cert_path: null + key_path: null +unix_socket: /run/headscale/headscale.sock diff --git a/hscontrol/types/testdata/compat/nixos-nixpkgs.yaml b/hscontrol/types/testdata/compat/nixos-nixpkgs.yaml new file mode 100644 index 000000000..f908fcb90 --- /dev/null +++ b/hscontrol/types/testdata/compat/nixos-nixpkgs.yaml @@ -0,0 +1,60 @@ +%YAML 1.1 +--- +database: + postgres: {} + sqlite: + path: /var/lib/headscale/db.sqlite + write_ahead_log: true + type: sqlite +derp: + auto_update_enabled: true + paths: [] + server: + private_key_path: /var/lib/headscale/derp_server_private.key + update_frequency: 24h + urls: + - https://controlplane.tailscale.com/derpmap/default +disable_check_updates: true +dns: + base_domain: tailnet.example.com + magic_dns: true + nameservers: + global: + - 1.1.1.1 + split: {} + override_local_dns: true + search_domains: [] +listen_addr: 127.0.0.1:8080 +log: + format: text + level: info +node: + ephemeral: + inactivity_timeout: 30m +noise: + private_key_path: /var/lib/headscale/noise_private.key +oidc: + allowed_domains: [] + allowed_users: [] + client_id: '' + extra_params: {} + issuer: '' + pkce: + enabled: false + method: S256 + scope: + - openid + - profile + - email +policy: + mode: file +prefixes: + allocation: sequential + v4: 100.64.0.0/10 + v6: fd7a:115c:a1e0::/48 +server_url: https://headscale.example.com +tls_letsencrypt_cache_dir: /var/lib/headscale/.cache +tls_letsencrypt_challenge_type: HTTP-01 +tls_letsencrypt_hostname: '' +tls_letsencrypt_listen: :http +unix_socket: /run/headscale/headscale.sock diff --git a/hscontrol/types/testdata/compat/oidc-secret.txt b/hscontrol/types/testdata/compat/oidc-secret.txt new file mode 100644 index 000000000..a837702b6 --- /dev/null +++ b/hscontrol/types/testdata/compat/oidc-secret.txt @@ -0,0 +1 @@ +marker-oidc-secret-from-file