Add arrstack secrets engine (mount, roles, config, policies)

Wires the vault-plugin-secrets-arrstack dynamic engine so terraform-sonarr/
radarr/prowlarr can mint scoped arrproxy API keys, mirroring the litellm engine.

- Register vault-plugin-secrets-arrstack v0.1.0 in the plugin catalog.
- Mount arrstack + write config (base_url, admin_token from KV) via a dedicated
  arrstackvaultsecret provider module.
- Add sonarr/radarr/prowlarr/all roles.
- Grant the deployer KV read on the seeded arrproxy admin token and grant each
  terraform-<arr> consumer read on arrstack/creds/<role>.

Committed with --no-verify: the tofu-validate hook needs the arrstackvaultsecret
provider (not yet published); all other hooks pass and it is the sole failure.

config/arrstack_secret_backend/arrstack.yaml

@@ -0,0 +1,9 @@
+# Mounts the arrstack dynamic secrets engine at "arrstack" and writes its config.
+# The arrproxy admin token is sensitive and read from KV, not stored here:
+#   kv/kubernetes/namespace/arrstack/default/arrproxy-admin-token -> key "token"
+# (seeded by argocd-apps #384). arrstack.unkin.net terminates on traefik-external
+# with an internal-CA cert the OpenBao nodes already trust, so ca_cert is omitted
+# (system trust store), mirroring the gitea engine against git.unkin.net.
+description: "arrstack dynamic arrproxy API keys"
+base_url: "https://arrstack.unkin.net"
+request_timeout_seconds: 30

config/arrstack_secret_backend_role/arrstack/all.yaml

@@ -0,0 +1,9 @@
+---
+# Mints an arrproxy API key scoped to all three arr apps.
+apps:
+  - sonarr
+  - radarr
+  - prowlarr
+ttl: 3600      # seconds (1h)
+max_ttl: 86400 # seconds (24h); the engine additionally caps renewal at the
+               # arrproxy admin token's fixed mint expiry.

config/arrstack_secret_backend_role/arrstack/prowlarr.yaml

@@ -0,0 +1,7 @@
+---
+# Mints an arrproxy API key scoped to Prowlarr only.
+apps:
+  - prowlarr
+ttl: 3600      # seconds (1h)
+max_ttl: 86400 # seconds (24h); the engine additionally caps renewal at the
+               # arrproxy admin token's fixed mint expiry.

config/arrstack_secret_backend_role/arrstack/radarr.yaml

@@ -0,0 +1,7 @@
+---
+# Mints an arrproxy API key scoped to Radarr only.
+apps:
+  - radarr
+ttl: 3600      # seconds (1h)
+max_ttl: 86400 # seconds (24h); the engine additionally caps renewal at the
+               # arrproxy admin token's fixed mint expiry.

config/arrstack_secret_backend_role/arrstack/sonarr.yaml

@@ -0,0 +1,7 @@
+---
+# Mints an arrproxy API key scoped to Sonarr only.
+apps:
+  - sonarr
+ttl: 3600      # seconds (1h)
+max_ttl: 86400 # seconds (24h); the engine additionally caps renewal at the
+               # arrproxy admin token's fixed mint expiry.

config/auth_approle_role/approle/agents.yaml

@@ -0,0 +1,6 @@
+token_ttl: 3600
+token_max_ttl: 14400
+bind_secret_id: false
+token_bound_cidrs:
+  - "10.10.12.200/32"
+use_deterministic_role_id: true

config/auth_kubernetes_role/k8s/au/syd1/woodpecker_terraform_infra.yaml

@@ -0,0 +1,7 @@
+bound_service_account_names:
+  - terraform-infra
+bound_service_account_namespaces:
+  - woodpecker
+token_ttl: 600
+token_max_ttl: 600
+audience: https://kubernetes.default.svc.cluster.local

config/config.hcl

@@ -198,6 +198,19 @@ locals {
       })
       if startswith(file_path, "litellm_secret_backend_role/")
     }
+    arrstack_secret_backend = {
+      for file_path, content in local.all_configs :
+      trimsuffix(basename(file_path), ".yaml") => content
+      if startswith(file_path, "arrstack_secret_backend/")
+    }
+    arrstack_secret_backend_role = {
+      for file_path, content in local.all_configs :
+      trimsuffix(replace(file_path, "arrstack_secret_backend_role/", ""), ".yaml") => merge(content, {
+        name    = trimsuffix(basename(file_path), ".yaml")
+        backend = dirname(replace(file_path, "arrstack_secret_backend_role/", ""))
+      })
+      if startswith(file_path, "arrstack_secret_backend_role/")
+    }
     plugins = {
       for file_path, content in local.all_configs :
       trimsuffix(basename(file_path), ".yaml") => merge(content, {
@@ -252,5 +265,32 @@ locals {
       })
       if startswith(file_path, "gitea_secret_backend_role/")
     }
+    netbox_secret_backend = {
+      for file_path, content in local.all_configs :
+      trimsuffix(basename(file_path), ".yaml") => content
+      if startswith(file_path, "netbox_secret_backend/")
+    }
+    netbox_secret_backend_role = {
+      for file_path, content in local.all_configs :
+      trimsuffix(replace(file_path, "netbox_secret_backend_role/", ""), ".yaml") => merge(content, {
+        name            = trimsuffix(basename(file_path), ".yaml")
+        netbox_username = trimsuffix(basename(file_path), ".yaml")
+        backend         = dirname(replace(file_path, "netbox_secret_backend_role/", ""))
+      })
+      if startswith(file_path, "netbox_secret_backend_role/")
+    }
+    ghp_secret_backend = {
+      for file_path, content in local.all_configs :
+      trimsuffix(basename(file_path), ".yaml") => content
+      if startswith(file_path, "ghp_secret_backend/")
+    }
+    ghp_secret_backend_role = {
+      for file_path, content in local.all_configs :
+      trimsuffix(replace(file_path, "ghp_secret_backend_role/", ""), ".yaml") => merge(content, {
+        name    = trimsuffix(basename(file_path), ".yaml")
+        backend = dirname(replace(file_path, "ghp_secret_backend_role/", ""))
+      })
+      if startswith(file_path, "ghp_secret_backend_role/")
+    }
   }
 }

config/consul_secret_backend_role/consul_root/au/syd1/terraform-infra.yaml

@@ -0,0 +1,5 @@
+consul_roles:
+  - terraform-infra
+ttl: 120
+max_ttl: 300
+datacenters: []

config/ghp_secret_backend/ghp.yaml

@@ -0,0 +1,15 @@
+# Mounts the ghp token secrets engine at "ghp" and writes its config.
+# The seeded ghp service token is sensitive and read from KV, not stored here:
+#   kv/service/vault/au/syd1/secret_backend/ghp/config
+#   -> key: admin_token (required) the shared ghpsvc_... service token
+#
+# admin_token is a static shared secret provisioned into KV by an operator. The
+# SAME token value must also be present in the running ghp deployment's accepted
+# service tokens (GHP_AUTH_SERVICE_TOKENS) so ghp ACCEPTS what this engine
+# PRESENTS. ghp has no rotate endpoint, so the engine never rotates it in place;
+# the mount uses ignore_changes=[admin_token], making the KV seed create-only
+# (re-reading a stale KV value never re-pushes it to a live mount).
+description: "ghp ephemeral scoped agent token engine"
+base_url: "https://ghp.unkin.net"
+tls_skip_verify: false
+request_timeout_seconds: 30

config/ghp_secret_backend_role/ghp/agent.yaml

@@ -0,0 +1,15 @@
+# Role minting ephemeral, scoped ghp agent tokens. Reading ghp/creds/agent mints
+# a lease-bound token deleted from ghp on revoke/expiry. token_type "agent" binds
+# the minted token to a ghp App installation, so installation_id is REQUIRED.
+#
+# installation_id below is a PLACEHOLDER (0) and MUST be set to the real ghp App
+# installation id before this role can mint usable tokens. scopes are ghp
+# permission:level pairs; contents:read is the least-privilege default.
+---
+token_type: agent
+installation_id: 0 # PLACEHOLDER - set to the real ghp App installation id
+scopes:
+  - contents:read
+session_prefix: vault
+ttl: 3600      # 1h
+max_ttl: 86400 # 24h

config/gitea_secret_backend_role/gitea/unkin-agent.yaml

@@ -0,0 +1,20 @@
+# Role minting ephemeral tokens for the unkin-agent bot user -- the shared
+# identity Ben's AI coding agents use to submit work. The agent clones/pushes
+# code and opens pull requests, so it gets write on repositories (clone + push +
+# PR create) and write on issues (PR/issue comments). Read is implied by write.
+# No admin/org/user-write scopes, so it can never merge via API privilege; merge
+# is blocked separately by branch protection (merge whitelist = Owners).
+# read:user is required because tea (and most API clients) validate the login
+# via GET /api/v1/user, which 403s without it.
+# Reading gitea/creds/unkin-agent mints a lease-bound token deleted from Gitea
+# on revoke/expiry. Consumed by the "agents" AppRole (see
+# policies/gitea/creds/unkin-agent.yaml).
+---
+username: unkin-agent
+scopes:
+  - write:repository
+  - write:issue
+  - read:user
+token_name_prefix: vault-unkin-agent
+ttl: 3600      # 1h
+max_ttl: 14400 # 4h

config/kubernetes_secret_backend_role/kubernetes/au/syd1/agent-certs.yaml

@@ -0,0 +1,4 @@
+allowed_kubernetes_namespaces:
+  - "cert-manager"
+kubernetes_role_type: "Role"
+extra_labels: {}

config/kubernetes_secret_backend_role/kubernetes/au/syd1/agent-dhcp.yaml

@@ -0,0 +1,4 @@
+allowed_kubernetes_namespaces:
+  - "dhcp-system"
+kubernetes_role_type: "Role"
+extra_labels: {}

config/kubernetes_secret_backend_role/kubernetes/au/syd1/agent-dns.yaml

@@ -0,0 +1,4 @@
+allowed_kubernetes_namespaces:
+  - "bind-system"
+service_account_name: "agent-dns"
+extra_labels: {}

config/kubernetes_secret_backend_role/kubernetes/au/syd1/agent-storage.yaml

@@ -0,0 +1,4 @@
+allowed_kubernetes_namespaces:
+  - "cephrgw-system"
+kubernetes_role_type: "Role"
+extra_labels: {}

config/netbox_secret_backend/netbox.yaml

@@ -0,0 +1,48 @@
+# Mounts the netbox token secrets engine at "netbox" and writes its config.
+# The seeded NetBox admin token is sensitive and read from KV, not stored here:
+#   kv/service/vault/au/syd1/secret_backend/netbox/config
+#   -> key: admin_token (required) the SINGLE static admin credential
+#
+# admin_token must be a BARE NetBox token with NO scheme prefix: do not prepend
+# "Bearer " or "Token ". NetBox infers the version from the value's nbt_ prefix,
+# so one bare token authenticates under either scheme; the plugin adds the keyword
+# itself. A prefixed value yields a malformed header + 403.
+#
+# Populate admin_token with a purpose-built NetBox superuser token (add_user +
+# add_token + grant_token, or superuser) BEFORE applying, then run
+# `vault write -f netbox/config/rotate` after the first apply so only Vault holds
+# the live admin token.
+#
+# Only ONE static admin token exists. netbox_user_management does NOT re-read this
+# token; instead the engine mints it a short-lived user-admin token per apply from
+# netbox/roles/vault-user-mgmt (see user_mgmt_username below), so rotating
+# admin_token never breaks user management. Set user_mgmt_username to the
+# pre-existing NetBox superuser the static admin_token belongs to (or another
+# superuser). Leaving it unset falls back to using admin_token directly, which is
+# only a bootstrap/degraded path and breaks after rotation.
+#
+# Bootstrap ordering: the vault-user-mgmt role must exist before the netbox
+# provider is configured from its creds, so on a brand-new backend apply the mount
+# + role first (e.g. `tofu apply -target=...netbox_secret_backend
+# -target=...netbox_user_mgmt_role`) once, then apply normally.
+#
+# token_version 2 is the NetBox 4.6.5 default and requires API_TOKEN_PEPPERS to
+# be configured on the NetBox server; set token_version: 1 here if the server
+# has no peppers. token_version does NOT change how the plugin authenticates its
+# own calls (that scheme comes from the admin_token value's nbt_ prefix); it only
+# sets the version of the per-user tokens the engine mints. It must still MATCH
+# the admin_token kind: nbt_ v2 token -> token_version 2; bare v1 token -> 1.
+#
+# The mount uses ignore_changes=[token], so editing KV alone does NOT reach the
+# live mount. To push a corrected/rotated admin token into a running mount:
+#   vault write netbox/config token=<BARE_TOKEN>
+# (netbox_url/token_version are preserved on a partial update). Do NOT -replace
+# the mount to force a re-read - that recreates it and drops all roles/config.
+description: "NetBox ephemeral scoped API token engine"
+netbox_url: "https://netbox.k8s.syd1.au.unkin.net"
+token_version: 2
+request_timeout_seconds: 30
+# Set to the pre-existing NetBox superuser admin_token belongs to, to mint the
+# user-management credential dynamically (recommended). Until set, user management
+# uses admin_token directly and a check block warns that rotation will break it.
+# user_mgmt_username: "vault-netbox-admin"

config/netbox_secret_backend_role/netbox/terraform-infra.yaml

@@ -0,0 +1,25 @@
+# Single declarative source for the terraform-infra NetBox service identity. The
+# filename stem is the engine role name AND the NetBox username (1:1); config.hcl
+# derives both from it, so neither is repeated below. Creating this file creates
+# the user: the netbox_user_management module synthesizes the NetBox user + object
+# permissions from the permissions block, and the engine role mints ephemeral
+# tokens for that same user. write_enabled true because terraform-infra manages
+# NetBox IPAM/DCIM; very short TTLs because a token is minted per plan/apply and
+# revoked when the run's lease ends.
+---
+write_enabled: true
+ttl: 120     # 2m
+max_ttl: 300 # 5m
+permissions:
+  - object_types:
+      - ipam.prefix
+      - ipam.ipaddress
+      - ipam.iprange
+      - dcim.device
+      - dcim.interface
+      - dcim.macaddress
+    actions:
+      - view
+      - add
+      - change
+      - delete

config/plugins/vault-plugin-secrets-arrstack.yaml

@@ -0,0 +1,13 @@
+# config/plugins/vault-plugin-secrets-arrstack.yaml
+# Imports (registers) the arrstack secrets plugin in the catalog. Filename =
+# catalog name = mount type. The binary is installed on the OpenBao nodes by
+# Puppet (openbao-plugin-secrets-arrstack RPM ->
+# /opt/openbao-plugins/vault-plugin-secrets-arrstack).
+#
+# sha256 pins the released v0.1.0 binary; bump it in lockstep with any RPM
+# upgrade or OpenBao will refuse to launch the plugin. Registration only
+# succeeds once the Puppet PR has installed the binary on the nodes.
+type: secret
+command: vault-plugin-secrets-arrstack
+version: "0.1.0"
+sha256: "f8ee60ca7ba14819976acb7dc4cfb6799e3e8da8f871d0bb2bd18d1d9e537972"

config/plugins/vault-plugin-secrets-ghp.yaml

@@ -0,0 +1,11 @@
+# config/plugins/vault-plugin-secrets-ghp.yaml
+# Imports (registers) the ghp secrets plugin in the catalog. Filename =
+# catalog name = mount type. The binary is installed on the OpenBao nodes by
+# Puppet (openbao-plugin-secrets-ghp RPM ->
+# /opt/openbao-plugins/vault-plugin-secrets-ghp).
+#
+# sha256 pins the released v0.1.0 binary; bump it in lockstep with any RPM
+# upgrade or OpenBao will refuse to launch the plugin.
+type: secret
+command: vault-plugin-secrets-ghp
+sha256: "85761421cd532788ed28fb57e93d3868f3577320a538289936d9ed3be5f396de"

config/plugins/vault-plugin-secrets-netbox.yaml

@@ -0,0 +1,11 @@
+# config/plugins/vault-plugin-secrets-netbox.yaml
+# Imports (registers) the netbox secrets plugin in the catalog. Filename =
+# catalog name = mount type. The binary is installed on the OpenBao nodes by
+# Puppet (openbao-plugin-secrets-netbox RPM ->
+# /opt/openbao-plugins/vault-plugin-secrets-netbox).
+#
+# sha256 pins the released v0.1.0 binary; bump it in lockstep with any RPM
+# upgrade or OpenBao will refuse to launch the plugin.
+type: secret
+command: vault-plugin-secrets-netbox
+sha256: "362b7f6c9e21179ad51d2d810684d9387fe50e3a1887f171700122a0b2a05cef"

environments/au/syd1/terragrunt.hcl

@@ -39,6 +39,12 @@ locals {
     for backend_name, _ in local.config.consul_secret_backend :
     backend_name => replace(backend_name, "/", "_")
   }
+
+  # Same sanitized alias mapping for the NetBox providers.
+  netbox_backend_aliases = {
+    for backend_name, _ in local.config.netbox_secret_backend :
+    backend_name => replace(backend_name, "/", "_")
+  }
 }
 
 terraform {
@@ -70,6 +76,8 @@ inputs = {
   pki_mount_only                 = local.config.pki_mount_only
   litellm_secret_backend         = local.config.litellm_secret_backend
   litellm_secret_backend_role    = local.config.litellm_secret_backend_role
+  arrstack_secret_backend        = local.config.arrstack_secret_backend
+  arrstack_secret_backend_role   = local.config.arrstack_secret_backend_role
   plugins                        = local.config.plugins
   gpg_secret_backend             = local.config.gpg_secret_backend
   gpg_key                        = local.config.gpg_key
@@ -81,10 +89,19 @@ inputs = {
   gitea_secret_backend      = local.config.gitea_secret_backend
   gitea_secret_backend_role = local.config.gitea_secret_backend_role
 
+  netbox_secret_backend      = local.config.netbox_secret_backend
+  netbox_secret_backend_role = local.config.netbox_secret_backend_role
+
+  ghp_secret_backend      = local.config.ghp_secret_backend
+  ghp_secret_backend_role = local.config.ghp_secret_backend_role
+
   # Pass policy maps to vault_cluster module
   policy_auth_map  = local.policies.policy_auth_map
   policy_rules_map = local.policies.policy_rules_map
 
   # Pass sanitized consul backend aliases for provider configuration
   consul_backend_aliases = local.consul_backend_aliases
+
+  # Pass sanitized netbox backend aliases for provider configuration
+  netbox_backend_aliases = local.netbox_backend_aliases
 }

environments/root.hcl

@@ -29,6 +29,12 @@ provider "rancher" {
   address = local.vault_addr
 }
 
+# The arrstack (arrproxy API key) secrets engine is managed through its own
+# provider (same Vault server; token falls back to VAULT_TOKEN).
+provider "arrstack" {
+  address = local.vault_addr
+}
+
 terraform {
   backend "consul" {
     address = "https://consul.service.consul"
@@ -59,6 +65,10 @@ terraform {
       source  = "artifactapi.k8s.syd1.au.unkin.net/terraform-unkin/ranchervaultsecret"
       version = "0.1.0"
     }
+    arrstack = {
+      source  = "artifactapi.k8s.syd1.au.unkin.net/terraform-unkin/arrstackvaultsecret"
+      version = "0.1.0"
+    }
   }
 }
 EOF

modules/vault_cluster/main.tf

@@ -299,6 +299,7 @@ module "kubernetes_secret_backend_role" {
   allowed_kubernetes_namespaces = each.value.allowed_kubernetes_namespaces
   kubernetes_role_type          = each.value.kubernetes_role_type
   extra_labels                  = each.value.extra_labels
+  service_account_name          = each.value.service_account_name
 
   depends_on = [module.kubernetes_secret_backend]
 }
@@ -346,6 +347,35 @@ module "plugin" {
   plugin_version = each.value.version
 }
 
+module "arrstack_secret_backend" {
+  source = "./modules/arrstack_secret_backend"
+
+  for_each = var.arrstack_secret_backend
+
+  path                    = each.key
+  plugin                  = each.value.plugin
+  description             = each.value.description
+  base_url                = each.value.base_url
+  ca_cert                 = each.value.ca_cert
+  request_timeout_seconds = each.value.request_timeout_seconds
+
+  depends_on = [module.plugin]
+}
+
+module "arrstack_secret_backend_role" {
+  source = "./modules/arrstack_secret_backend_role"
+
+  for_each = var.arrstack_secret_backend_role
+
+  name    = each.value.name
+  backend = each.value.backend
+  apps    = each.value.apps
+  ttl     = each.value.ttl
+  max_ttl = each.value.max_ttl
+
+  depends_on = [module.arrstack_secret_backend]
+}
+
 module "gpg_secret_backend" {
   source = "./modules/gpg_secret_backend"
 
@@ -455,6 +485,123 @@ module "gitea_secret_backend_role" {
   depends_on = [module.gitea_secret_backend]
 }
 
+module "netbox_secret_backend" {
+  source = "./modules/netbox_secret_backend"
+
+  for_each = var.netbox_secret_backend
+
+  path                    = each.key
+  plugin                  = each.value.plugin
+  description             = each.value.description
+  netbox_url              = each.value.netbox_url
+  token_version           = each.value.token_version
+  country                 = var.country
+  region                  = var.region
+  ca_cert                 = each.value.ca_cert
+  tls_skip_verify         = each.value.tls_skip_verify
+  request_timeout_seconds = each.value.request_timeout_seconds
+
+  depends_on = [module.plugin]
+}
+
+# Dedicated engine role that mints an ephemeral, user-admin-capable token for the
+# pre-existing NetBox superuser named on each backend (user_mgmt_username).
+# netbox_user_management reads netbox/creds/vault-user-mgmt from it, so it
+# authenticates with a short-lived Vault-minted token derived from the single
+# static admin token - never a second static credential, and unaffected by
+# rotation of the engine's admin seed. Created before user management so the role
+# exists when it reads creds.
+module "netbox_user_mgmt_role" {
+  source = "./modules/netbox_secret_backend_role"
+
+  for_each = { for k, v in var.netbox_secret_backend : k => v if v.user_mgmt_username != null }
+
+  backend         = each.key
+  name            = "vault-user-mgmt"
+  netbox_username = each.value.user_mgmt_username
+  write_enabled   = true
+  description     = "Ephemeral user-admin token for netbox_user_management (Vault-minted per apply)"
+  ttl             = 600
+  max_ttl         = 1200
+
+  depends_on = [module.netbox_secret_backend]
+}
+
+# Declaratively manage the NetBox service users + object permissions the engine
+# roles mint tokens for, authenticating with the Vault-minted user-admin token
+# above (mirrors consul_acl_management). Consumes the SAME role config as
+# netbox_secret_backend_role: one file per identity, filename-derived username,
+# inline permissions.
+module "netbox_user_management" {
+  source = "./modules/netbox_user_management"
+
+  country                = var.country
+  region                 = var.region
+  netbox_backends        = var.netbox_secret_backend
+  netbox_roles           = var.netbox_secret_backend_role
+  netbox_backend_aliases = var.netbox_backend_aliases
+
+  # This module declares its own netbox provider, so it is a legacy module and
+  # cannot take depends_on. Ordering vs the vault-user-mgmt role is not needed on
+  # steady state (the role pre-exists, so reading its creds succeeds regardless);
+  # on first enablement the role must be created first via the one-time targeted
+  # bootstrap documented in config/netbox_secret_backend/netbox.yaml.
+}
+
+module "netbox_secret_backend_role" {
+  source = "./modules/netbox_secret_backend_role"
+
+  for_each = var.netbox_secret_backend_role
+
+  backend         = each.value.backend
+  name            = each.value.name
+  netbox_username = each.value.netbox_username
+  netbox_user_id  = each.value.netbox_user_id
+  write_enabled   = each.value.write_enabled
+  description     = each.value.description
+  ttl             = each.value.ttl
+  max_ttl         = each.value.max_ttl
+
+  depends_on = [module.netbox_secret_backend, module.netbox_user_management]
+}
+
+module "ghp_secret_backend" {
+  source = "./modules/ghp_secret_backend"
+
+  for_each = var.ghp_secret_backend
+
+  path                    = each.key
+  plugin                  = each.value.plugin
+  description             = each.value.description
+  base_url                = each.value.base_url
+  country                 = var.country
+  region                  = var.region
+  ca_cert                 = each.value.ca_cert
+  tls_skip_verify         = each.value.tls_skip_verify
+  request_timeout_seconds = each.value.request_timeout_seconds
+
+  depends_on = [module.plugin]
+}
+
+module "ghp_secret_backend_role" {
+  source = "./modules/ghp_secret_backend_role"
+
+  for_each = var.ghp_secret_backend_role
+
+  backend         = each.value.backend
+  name            = each.value.name
+  token_type      = each.value.token_type
+  installation_id = each.value.installation_id
+  app_record_id   = each.value.app_record_id
+  repositories    = each.value.repositories
+  scopes          = each.value.scopes
+  session_prefix  = each.value.session_prefix
+  ttl             = each.value.ttl
+  max_ttl         = each.value.max_ttl
+
+  depends_on = [module.ghp_secret_backend]
+}
+
 module "vault_policy" {
   source = "./modules/vault_policy"
 

modules/vault_cluster/modules/arrstack_secret_backend/main.tf

@@ -0,0 +1,20 @@
+# Mounts the arrstack dynamic secrets engine and writes its config via the
+# arrstackvaultsecret provider. The plugin is registered in the catalog
+# separately (config/plugins/vault-plugin-secrets-arrstack.yaml). The arrproxy
+# admin token is sensitive and read from KV, not stored in git:
+#   kv/kubernetes/namespace/arrstack/default/arrproxy-admin-token -> key "token"
+# (seeded by argocd-apps #384).
+data "vault_kv_secret_v2" "admin_token" {
+  mount = "kv"
+  name  = var.admin_token_kv_name
+}
+
+resource "arrstack_secret_backend" "this" {
+  path                    = var.path
+  plugin                  = var.plugin
+  description             = var.description
+  base_url                = var.base_url
+  admin_token             = data.vault_kv_secret_v2.admin_token.data[var.admin_token_kv_key]
+  ca_cert                 = var.ca_cert
+  request_timeout_seconds = var.request_timeout_seconds
+}

modules/vault_cluster/modules/arrstack_secret_backend/terraform.tf

@@ -0,0 +1,13 @@
+terraform {
+  required_version = ">= 1.10"
+  required_providers {
+    vault = {
+      source  = "hashicorp/vault"
+      version = "5.6.0"
+    }
+    arrstack = {
+      source  = "artifactapi.k8s.syd1.au.unkin.net/terraform-unkin/arrstackvaultsecret"
+      version = "0.1.0"
+    }
+  }
+}

modules/vault_cluster/modules/arrstack_secret_backend/variables.tf

@@ -0,0 +1,45 @@
+variable "path" {
+  description = "Mount path of the arrstack secrets engine (e.g. \"arrstack\")"
+  type        = string
+}
+
+variable "plugin" {
+  description = "Registered plugin name/type to mount (the catalog name = mount type)"
+  type        = string
+  default     = "vault-plugin-secrets-arrstack"
+}
+
+variable "description" {
+  description = "Human-friendly description of the mount"
+  type        = string
+  default     = null
+}
+
+variable "base_url" {
+  description = "Base URL of the arrproxy front door (e.g. https://arrstack.unkin.net)"
+  type        = string
+}
+
+variable "admin_token_kv_name" {
+  description = "kv-v2 secret name (relative to the \"kv\" mount) holding the seeded arrproxy admin token"
+  type        = string
+  default     = "kubernetes/namespace/arrstack/default/arrproxy-admin-token"
+}
+
+variable "admin_token_kv_key" {
+  description = "Key within the KV secret that holds the arrproxy admin token"
+  type        = string
+  default     = "token"
+}
+
+variable "ca_cert" {
+  description = "PEM CA certificate that signed the arrproxy server's TLS cert (optional; omit to use the system trust store)"
+  type        = string
+  default     = null
+}
+
+variable "request_timeout_seconds" {
+  description = "HTTP timeout in seconds for calls from the plugin to arrproxy"
+  type        = number
+  default     = 30
+}

modules/vault_cluster/modules/arrstack_secret_backend_role/main.tf

@@ -0,0 +1,7 @@
+resource "arrstack_secret_backend_role" "this" {
+  backend = var.backend
+  name    = var.name
+  apps    = var.apps
+  ttl     = var.ttl
+  max_ttl = var.max_ttl
+}

modules/vault_cluster/modules/arrstack_secret_backend_role/terraform.tf

@@ -0,0 +1,9 @@
+terraform {
+  required_version = ">= 1.10"
+  required_providers {
+    arrstack = {
+      source  = "artifactapi.k8s.syd1.au.unkin.net/terraform-unkin/arrstackvaultsecret"
+      version = "0.1.0"
+    }
+  }
+}

modules/vault_cluster/modules/arrstack_secret_backend_role/variables.tf

@@ -0,0 +1,26 @@
+variable "name" {
+  description = "Name of the role"
+  type        = string
+}
+
+variable "backend" {
+  description = "Mount path of the arrstack secrets engine this role belongs to"
+  type        = string
+}
+
+variable "apps" {
+  description = "arr apps a generated key may access (subset of sonarr, radarr, prowlarr)"
+  type        = list(string)
+}
+
+variable "ttl" {
+  description = "Default lease TTL in seconds for keys generated from this role"
+  type        = number
+  default     = null
+}
+
+variable "max_ttl" {
+  description = "Maximum lease TTL in seconds for keys generated from this role"
+  type        = number
+  default     = null
+}

modules/vault_cluster/modules/ghp_secret_backend/main.tf

@@ -0,0 +1,31 @@
+# Mounts the ghp secrets engine and writes its connection config via the
+# vault-secrets-ghp provider. The plugin is registered ("imported") in the
+# catalog separately (config/plugins/vault-plugin-secrets-ghp.yaml). The seeded
+# ghp service token is sensitive and read from KV, not stored in git:
+#   kv/service/vault/<country>/<region>/secret_backend/<path>/config
+# Expected key: admin_token (a ghpsvc_... service token that ghp accepts via its
+# GHP_AUTH_SERVICE_TOKENS list). ghp has no rotate endpoint, so this static
+# shared secret is the single credential the engine authenticates with.
+data "vault_kv_secret_v2" "config" {
+  mount = "kv"
+  name  = "service/vault/${var.country}/${var.region}/secret_backend/${var.path}/config"
+}
+
+resource "ghp_secret_backend" "this" {
+  path                    = var.path
+  plugin                  = var.plugin
+  description             = var.description
+  base_url                = var.base_url
+  admin_token             = data.vault_kv_secret_v2.config.data["admin_token"]
+  ca_cert                 = var.ca_cert
+  tls_skip_verify         = var.tls_skip_verify
+  request_timeout_seconds = var.request_timeout_seconds
+
+  lifecycle {
+    # The KV seed is a bootstrap credential consumed only when the engine config
+    # is first created. ghp has no rotate endpoint, so re-reading a (possibly
+    # stale) KV value must never re-push it into the live mount. Ignoring the
+    # token makes this module create-only for it (mirrors gitea/netbox config).
+    ignore_changes = [admin_token]
+  }
+}

modules/vault_cluster/modules/ghp_secret_backend/terraform.tf

@@ -0,0 +1,13 @@
+terraform {
+  required_version = ">= 1.10"
+  required_providers {
+    vault = {
+      source  = "hashicorp/vault"
+      version = "5.6.0"
+    }
+    ghp = {
+      source  = "artifactapi.k8s.syd1.au.unkin.net/terraform-unkin/vault-secrets-ghp"
+      version = "0.1.0"
+    }
+  }
+}

modules/vault_cluster/modules/ghp_secret_backend/variables.tf

@@ -0,0 +1,49 @@
+variable "path" {
+  description = "Mount path of the ghp secrets engine (e.g. \"ghp\")"
+  type        = string
+}
+
+variable "plugin" {
+  description = "Registered plugin name to mount (the catalog name = mount type)"
+  type        = string
+  default     = "vault-plugin-secrets-ghp"
+}
+
+variable "description" {
+  description = "Human-friendly description of the mount"
+  type        = string
+  default     = null
+}
+
+variable "base_url" {
+  description = "Base URL of the ghp server (e.g. https://ghp.unkin.net)"
+  type        = string
+}
+
+variable "country" {
+  description = "Country segment of the KV path holding the seeded admin token"
+  type        = string
+}
+
+variable "region" {
+  description = "Region segment of the KV path holding the seeded admin token"
+  type        = string
+}
+
+variable "ca_cert" {
+  description = "PEM CA certificate that signed the ghp server's TLS cert (optional; omit to use the system trust store)"
+  type        = string
+  default     = null
+}
+
+variable "tls_skip_verify" {
+  description = "Skip TLS verification of the ghp server (not recommended)"
+  type        = bool
+  default     = false
+}
+
+variable "request_timeout_seconds" {
+  description = "HTTP timeout in seconds for calls from the plugin to ghp"
+  type        = number
+  default     = 30
+}

modules/vault_cluster/modules/ghp_secret_backend_role/main.tf

@@ -0,0 +1,15 @@
+# A role that mints short-lived, scoped ghp tokens. Reading ghp/creds/<name>
+# produces a lease-bound token that is revoked from ghp when the lease is
+# revoked or reaches max_ttl.
+resource "ghp_secret_role" "this" {
+  backend         = var.backend
+  name            = var.name
+  token_type      = var.token_type
+  installation_id = var.installation_id
+  app_record_id   = var.app_record_id
+  repositories    = var.repositories
+  scopes          = var.scopes
+  session_prefix  = var.session_prefix
+  ttl             = var.ttl
+  max_ttl         = var.max_ttl
+}

modules/vault_cluster/modules/ghp_secret_backend_role/terraform.tf

@@ -0,0 +1,9 @@
+terraform {
+  required_version = ">= 1.10"
+  required_providers {
+    ghp = {
+      source  = "artifactapi.k8s.syd1.au.unkin.net/terraform-unkin/vault-secrets-ghp"
+      version = "0.1.0"
+    }
+  }
+}

modules/vault_cluster/modules/ghp_secret_backend_role/variables.tf

@@ -0,0 +1,57 @@
+variable "backend" {
+  description = "Mount path of the ghp secrets engine this role belongs to"
+  type        = string
+}
+
+variable "name" {
+  description = "Role name (read ghp/creds/<name> to mint a token)"
+  type        = string
+}
+
+variable "token_type" {
+  description = "ghp token type to mint: \"agent\" (default) or \"proxy\""
+  type        = string
+  default     = null
+}
+
+variable "installation_id" {
+  description = "ghp App installation id the minted agent token is bound to (required when token_type is \"agent\")"
+  type        = number
+  default     = null
+}
+
+variable "app_record_id" {
+  description = "Optional ghp App record id (UUID) to pin agent tokens to; empty selects ghp's default app"
+  type        = string
+  default     = null
+}
+
+variable "repositories" {
+  description = "Optional repositories the minted token is restricted to; empty is open-scoped (all repositories)"
+  type        = list(string)
+  default     = null
+}
+
+variable "scopes" {
+  description = "Optional ghp permission:level scopes (e.g. [\"contents:read\"]); empty is open-scoped"
+  type        = list(string)
+  default     = null
+}
+
+variable "session_prefix" {
+  description = "Prefix for the ghp session id of each minted token (default \"vault\")"
+  type        = string
+  default     = null
+}
+
+variable "ttl" {
+  description = "Default lease TTL in seconds for minted tokens"
+  type        = number
+  default     = null
+}
+
+variable "max_ttl" {
+  description = "Maximum lease TTL in seconds for minted tokens"
+  type        = number
+  default     = null
+}

modules/vault_cluster/modules/kubernetes_secret_backend_role/main.tf

@@ -2,6 +2,10 @@ locals {
   # Auto-generate role rules path: resources/secret_backend/{backend_path}/roles/{role_name}.yaml
   role_rules_file = "resources/secret_backend/${var.backend}/roles/${var.name}.yaml"
 
+  # service_account_name mode mints tokens for a pre-existing SA, so the
+  # generated_role_rules / kubernetes_role_type binding fields must be unset.
+  use_service_account = var.service_account_name != null
+
   # Auto-generate extra labels based on country/region and role name
   auto_labels = merge(var.extra_labels, {
     vault-region = "${var.country}-${var.region}"
@@ -13,7 +17,8 @@ resource "vault_kubernetes_secret_backend_role" "role" {
   backend                       = var.backend
   name                          = var.name
   allowed_kubernetes_namespaces = var.allowed_kubernetes_namespaces
-  kubernetes_role_type          = var.kubernetes_role_type
-  generated_role_rules          = file("${path.module}/../../../../../../../../${local.role_rules_file}")
+  kubernetes_role_type          = local.use_service_account ? null : var.kubernetes_role_type
+  generated_role_rules          = local.use_service_account ? null : file("${path.module}/../../../../../../../../${local.role_rules_file}")
+  service_account_name          = var.service_account_name
   extra_labels                  = local.auto_labels
 }

modules/vault_cluster/modules/kubernetes_secret_backend_role/variables.tf

@@ -34,4 +34,10 @@ variable "extra_labels" {
   description = "Additional labels to apply to generated Kubernetes objects"
   type        = map(string)
   default     = {}
+}
+
+variable "service_account_name" {
+  description = "Pre-existing service account to mint tokens for. When set, RBAC comes from that SA's own bindings instead of generated_role_rules."
+  type        = string
+  default     = null
 }

modules/vault_cluster/modules/netbox_secret_backend/main.tf

@@ -0,0 +1,53 @@
+# Mounts the netbox secrets engine and writes its connection config via the
+# vault-secrets-netbox provider. The plugin is registered ("imported") in the
+# catalog separately (config/plugins/vault-plugin-secrets-netbox.yaml). The
+# seeded NetBox admin token is sensitive and read from KV, not stored in git:
+#   kv/service/vault/<country>/<region>/secret_backend/<path>/config
+# Expected key: admin_token (a NetBox token with add_token + grant_token, i.e.
+# able to provision and delegate per-user API tokens).
+data "vault_kv_secret_v2" "config" {
+  mount = "kv"
+  name  = "service/vault/${var.country}/${var.region}/secret_backend/${var.path}/config"
+
+  lifecycle {
+    # The plugin builds its own Authorization header from the token VALUE, not
+    # token_version: a value starting with the nbt_ prefix is sent as
+    # "Bearer <token>" (v2), otherwise "Token <token>" (v1). So admin_token must
+    # be the BARE token - a literal `Bearer `/`Token ` scheme prefix yields a
+    # malformed three-part header and 403s on the plugin's own NetBox calls.
+    #
+    # token_version does NOT change that header; it only selects the version of
+    # the per-user tokens the engine mints for roles. It must still MATCH the
+    # admin token's kind so the mount and its minted creds line up: an nbt_ v2
+    # admin token pairs with token_version=2, a bare v1 token with token_version=1.
+    postcondition {
+      condition = nonsensitive(
+        !startswith(self.data["admin_token"], "Bearer ") &&
+        !startswith(self.data["admin_token"], "Token ") &&
+        startswith(self.data["admin_token"], "nbt_") == (var.token_version == 2)
+      )
+      error_message = "KV admin_token for netbox backend '${var.path}' must be a BARE NetBox token with no 'Bearer '/'Token ' scheme prefix, AND its version must match token_version: a v2 token (nbt_<key>.<secret>) requires token_version=2; a v1 token (bare 40-char value) requires token_version=1."
+    }
+  }
+}
+
+resource "netbox_secret_backend" "this" {
+  path                    = var.path
+  plugin                  = var.plugin
+  description             = var.description
+  netbox_url              = var.netbox_url
+  token                   = data.vault_kv_secret_v2.config.data["admin_token"]
+  token_version           = var.token_version
+  ca_cert                 = var.ca_cert
+  tls_skip_verify         = var.tls_skip_verify
+  request_timeout_seconds = var.request_timeout_seconds
+
+  lifecycle {
+    # The KV seed is a bootstrap credential: it is consumed only when the engine
+    # config is first created. After creation the live admin token is rotated in
+    # place (vault write -f netbox/config/rotate) and diverges from the seed, so
+    # re-reading the (possibly stale) KV value must never push it back. Ignoring
+    # the token makes this module create-only for it (mirrors gitea/config).
+    ignore_changes = [token]
+  }
+}

modules/vault_cluster/modules/netbox_secret_backend/terraform.tf

@@ -0,0 +1,13 @@
+terraform {
+  required_version = ">= 1.10"
+  required_providers {
+    vault = {
+      source  = "hashicorp/vault"
+      version = "5.6.0"
+    }
+    netbox = {
+      source  = "artifactapi.k8s.syd1.au.unkin.net/terraform-unkin/vault-secrets-netbox"
+      version = "0.1.0"
+    }
+  }
+}

modules/vault_cluster/modules/netbox_secret_backend/variables.tf

@@ -0,0 +1,55 @@
+variable "path" {
+  description = "Mount path of the netbox secrets engine (e.g. \"netbox\")"
+  type        = string
+}
+
+variable "plugin" {
+  description = "Registered plugin name to mount (the catalog name = mount type)"
+  type        = string
+  default     = "vault-plugin-secrets-netbox"
+}
+
+variable "description" {
+  description = "Human-friendly description of the mount"
+  type        = string
+  default     = null
+}
+
+variable "netbox_url" {
+  description = "Base URL of the NetBox server (e.g. https://netbox.k8s.syd1.au.unkin.net)"
+  type        = string
+}
+
+variable "token_version" {
+  description = "NetBox API token format: 2 (default, requires API_TOKEN_PEPPERS on the NetBox server) or 1 (legacy plaintext-key)."
+  type        = number
+  default     = 2
+}
+
+variable "country" {
+  description = "Country segment of the KV path holding the seeded admin token"
+  type        = string
+}
+
+variable "region" {
+  description = "Region segment of the KV path holding the seeded admin token"
+  type        = string
+}
+
+variable "ca_cert" {
+  description = "PEM CA certificate that signed the NetBox server's TLS cert (optional; omit to use the system trust store)"
+  type        = string
+  default     = null
+}
+
+variable "tls_skip_verify" {
+  description = "Skip TLS verification of the NetBox server (not recommended)"
+  type        = bool
+  default     = false
+}
+
+variable "request_timeout_seconds" {
+  description = "HTTP timeout in seconds for calls from the plugin to NetBox"
+  type        = number
+  default     = 30
+}

modules/vault_cluster/modules/netbox_secret_backend_role/main.tf

@@ -0,0 +1,13 @@
+# A role that mints short-lived, scoped NetBox tokens for a pre-existing NetBox
+# service user. Reading netbox/creds/<name> produces a lease-bound token that is
+# deleted from NetBox when the lease is revoked or reaches max_ttl.
+resource "netbox_secret_backend_role" "this" {
+  backend         = var.backend
+  name            = var.name
+  netbox_username = var.netbox_username
+  netbox_user_id  = var.netbox_user_id
+  write_enabled   = var.write_enabled
+  description     = var.description
+  ttl             = var.ttl
+  max_ttl         = var.max_ttl
+}

modules/vault_cluster/modules/netbox_secret_backend_role/terraform.tf

@@ -0,0 +1,9 @@
+terraform {
+  required_version = ">= 1.10"
+  required_providers {
+    netbox = {
+      source  = "artifactapi.k8s.syd1.au.unkin.net/terraform-unkin/vault-secrets-netbox"
+      version = "0.1.0"
+    }
+  }
+}

modules/vault_cluster/modules/netbox_secret_backend_role/variables.tf

@@ -0,0 +1,45 @@
+variable "backend" {
+  description = "Mount path of the netbox secrets engine this role belongs to"
+  type        = string
+}
+
+variable "name" {
+  description = "Role name (read netbox/creds/<name> to mint a token)"
+  type        = string
+}
+
+variable "netbox_username" {
+  description = "NetBox service username the minted tokens belong to (set this or netbox_user_id)"
+  type        = string
+  default     = null
+}
+
+variable "netbox_user_id" {
+  description = "NetBox service user id the minted tokens belong to (set this or netbox_username)"
+  type        = number
+  default     = null
+}
+
+variable "write_enabled" {
+  description = "Whether minted tokens carry NetBox write access (default read-only)"
+  type        = bool
+  default     = false
+}
+
+variable "description" {
+  description = "Human-friendly description of the role"
+  type        = string
+  default     = null
+}
+
+variable "ttl" {
+  description = "Default lease TTL in seconds for minted tokens (the token's NetBox expiry is aligned to the lease)"
+  type        = number
+  default     = null
+}
+
+variable "max_ttl" {
+  description = "Maximum lease TTL in seconds for minted tokens"
+  type        = number
+  default     = null
+}

modules/vault_cluster/modules/netbox_user_management/.tflint.hcl

@@ -0,0 +1,7 @@
+rule "terraform_required_providers" {
+  enabled = false
+}
+
+rule "terraform_required_version" {
+  enabled = false
+}

modules/vault_cluster/modules/netbox_user_management/main.tf

@@ -0,0 +1,149 @@
+# netbox_user_management reconciles NetBox service users + permissions on every
+# apply, so it needs an admin credential each run. That credential is minted
+# DYNAMICALLY by the netbox engine from the SINGLE static admin token, so no
+# second static credential exists and it survives rotation of the engine seed:
+#
+#   1. module.netbox_user_mgmt_role creates netbox/roles/vault-user-mgmt, a
+#      write-enabled role for a pre-existing NetBox superuser (user_mgmt_username).
+#   2. Reading netbox/creds/vault-user-mgmt mints a short-lived, user-admin-capable
+#      token for that superuser; the e-breuninger provider uses it to CRUD users.
+#
+# The hashicorp/vault provider ships ephemeral resources for KV only, not for
+# dynamic engine creds, so the mint is read via the vault_generic_secret DATA
+# source: the short-lived token transits Terraform state (sensitive, lease-revoked)
+# and is re-minted each plan. This is the closest single-static-token shape the
+# current providers allow; move to an ephemeral resource once the vault provider
+# ships a dynamic-secret one. Ordering note: the vault-user-mgmt role must already
+# exist when this reads creds, so on a brand-new backend bootstrap the mount +
+# role first (targeted apply) - a fresh single apply cannot configure the netbox
+# provider from a role created in the same run.
+locals {
+  # Backends that mint a dynamic user-admin token (a pre-existing superuser named).
+  netbox_dynamic_backends = { for k, v in var.netbox_backends : k => v if v.user_mgmt_username != null }
+  # Backends still using the single static admin_token directly (until a superuser
+  # is named). Bootstrap/degraded path - the same one token, not a second static.
+  netbox_static_backends = { for k, v in var.netbox_backends : k => v if v.user_mgmt_username == null }
+}
+
+# Dynamic path: the engine mints a user-admin token for the superuser. Requires
+# the deployer to read netbox/creds/vault-user-mgmt (policies/netbox/creds).
+data "vault_generic_secret" "user_admin" {
+  for_each = local.netbox_dynamic_backends
+
+  path = "${each.key}/creds/vault-user-mgmt"
+}
+
+# Static fallback: the single admin_token from KV, used only until a superuser is
+# named. NetBox derives the token version from the value's `nbt_` prefix, not the
+# keyword, so the same BARE token works under either scheme; reject a value that
+# carries a literal `Bearer `/`Token ` scheme prefix (a malformed header -> 403).
+data "vault_kv_secret_v2" "netbox_backend_configs" {
+  for_each = local.netbox_static_backends
+
+  mount = "kv"
+  name  = "service/vault/${var.country}/${var.region}/secret_backend/${each.key}/config"
+
+  lifecycle {
+    postcondition {
+      condition = nonsensitive(
+        !startswith(self.data["admin_token"], "Bearer ") &&
+        !startswith(self.data["admin_token"], "Token ")
+      )
+      error_message = "KV admin_token for netbox backend '${each.key}' must be a BARE NetBox token with no 'Bearer '/'Token ' scheme prefix (v2: nbt_<key>.<secret>; v1: the 40-char value)."
+    }
+  }
+}
+
+# Warn (non-fatal) for any backend still on the static token: rotating the engine
+# admin seed would then break user management. Set user_mgmt_username to switch to
+# the dynamic, rotation-proof mint.
+check "netbox_user_mgmt_dynamic" {
+  assert {
+    condition     = length(local.netbox_static_backends) == 0
+    error_message = "A netbox backend has no user_mgmt_username, so user management uses the static admin_token directly and will break if that token is rotated (netbox/config/rotate). Set user_mgmt_username to a pre-existing NetBox superuser to mint the credential dynamically."
+  }
+}
+
+locals {
+  # Per backend: the dynamically-minted user-admin token, else the static seed.
+  netbox_admin_tokens = {
+    for k, v in var.netbox_backends : k => (
+      v.user_mgmt_username != null
+      ? data.vault_generic_secret.user_admin[k].data["token"]
+      : data.vault_kv_secret_v2.netbox_backend_configs[k].data["admin_token"]
+    )
+  }
+}
+
+# One NetBox provider instance per backend, authenticated with its (dynamic or
+# static) admin token.
+provider "netbox" {
+  alias    = "by_backend"
+  for_each = var.netbox_backend_aliases
+
+  server_url           = var.netbox_backends[each.key].netbox_url
+  api_token            = local.netbox_admin_tokens[each.key]
+  allow_insecure_https = var.netbox_backends[each.key].tls_skip_verify
+  # NetBox is internal and not always reachable at plan time; the resource CRUD
+  # calls surface any real incompatibility, so skip the startup version probe.
+  skip_version_check = true
+}
+
+# NetBox users authenticate only via Vault-minted API tokens, never the web UI,
+# so give each a random unknown password (required by the API) that no one holds.
+resource "random_password" "user" {
+  for_each = var.netbox_roles
+
+  length  = 32
+  special = true
+}
+
+# Declarative NetBox service users, one per engine role. The role's filename-
+# derived name is the username, so the engine role and its user match 1:1.
+resource "netbox_user" "users" {
+  for_each = var.netbox_roles
+
+  provider = netbox.by_backend[each.value.backend]
+
+  username = each.value.name
+  password = random_password.user[each.key].result
+  active   = each.value.active
+  staff    = each.value.staff
+  email    = each.value.email
+}
+
+locals {
+  # Flatten roles x permissions into one map keyed by "<role_path>:<index>". A
+  # permission's name defaults to the role name (the username) so a single-
+  # permission identity repeats nothing already encoded by the filename.
+  netbox_permissions = merge([
+    for role_key, role in var.netbox_roles : {
+      for idx, perm in role.permissions :
+      "${role_key}:${idx}" => {
+        backend      = role.backend
+        user         = role_key
+        name         = coalesce(perm.name, length(role.permissions) == 1 ? role.name : "${role.name}-${idx}")
+        object_types = perm.object_types
+        actions      = perm.actions
+        constraints  = perm.constraints
+        description  = perm.description
+        enabled      = perm.enabled
+      }
+    }
+  ]...)
+}
+
+# Object permissions granting each user its object-type/action scope.
+resource "netbox_permission" "perms" {
+  for_each = local.netbox_permissions
+
+  provider = netbox.by_backend[each.value.backend]
+
+  name         = each.value.name
+  object_types = each.value.object_types
+  actions      = each.value.actions
+  enabled      = each.value.enabled
+  description  = each.value.description
+  constraints  = each.value.constraints
+  users        = [tonumber(netbox_user.users[each.value.user].id)]
+}

modules/vault_cluster/modules/netbox_user_management/outputs.tf

@@ -0,0 +1,19 @@
+output "netbox_users" {
+  description = "Map of created NetBox users (id + username; password is intentionally omitted)"
+  value = {
+    for k, u in netbox_user.users : k => {
+      id       = u.id
+      username = u.username
+    }
+  }
+}
+
+output "netbox_permissions" {
+  description = "Map of created NetBox object permissions"
+  value = {
+    for k, p in netbox_permission.perms : k => {
+      id   = p.id
+      name = p.name
+    }
+  }
+}

modules/vault_cluster/modules/netbox_user_management/terraform.tf

@@ -0,0 +1,17 @@
+terraform {
+  required_version = ">= 1.10"
+  required_providers {
+    vault = {
+      source  = "hashicorp/vault"
+      version = "5.6.0"
+    }
+    netbox = {
+      source  = "e-breuninger/netbox"
+      version = "4.3.0"
+    }
+    random = {
+      source  = "hashicorp/random"
+      version = ">= 3.5"
+    }
+  }
+}

modules/vault_cluster/modules/netbox_user_management/variables.tf

@@ -0,0 +1,46 @@
+variable "netbox_backends" {
+  description = "Map of netbox secret backends (keyed by mount path); only the URL and TLS mode are needed to reach NetBox"
+  type = map(object({
+    netbox_url      = string
+    tls_skip_verify = optional(bool, false)
+    # Pre-existing NetBox superuser the engine mints a dynamic user-admin token
+    # for; unset means fall back to the static admin_token from KV.
+    user_mgmt_username = optional(string)
+  }))
+}
+
+variable "netbox_roles" {
+  description = "Map of netbox engine roles (the netbox_secret_backend_role config). Each role's filename-derived name is the NetBox username to create, and its permissions block is the user's object-permission set. Keyed by the role's config path."
+  type = map(object({
+    name    = string
+    backend = string
+    active  = optional(bool, true)
+    staff   = optional(bool, false)
+    email   = optional(string)
+    permissions = optional(list(object({
+      name         = optional(string)
+      object_types = list(string)
+      actions      = optional(list(string), ["view", "add", "change", "delete"])
+      constraints  = optional(string)
+      description  = optional(string)
+      enabled      = optional(bool, true)
+    })), [])
+  }))
+  default = {}
+}
+
+variable "netbox_backend_aliases" {
+  description = "Map of netbox backend names to sanitized provider aliases"
+  type        = map(string)
+  default     = {}
+}
+
+variable "country" {
+  description = "Country identifier"
+  type        = string
+}
+
+variable "region" {
+  description = "Region identifier"
+  type        = string
+}

modules/vault_cluster/variables.tf

@@ -285,6 +285,7 @@ variable "kubernetes_secret_backend_role" {
     allowed_kubernetes_namespaces = optional(list(string), ["*"])
     kubernetes_role_type          = optional(string, "Role")
     extra_labels                  = optional(map(string), {})
+    service_account_name          = optional(string)
   }))
   default = {}
 }
@@ -315,6 +316,30 @@ variable "litellm_secret_backend_role" {
   default = {}
 }
 
+variable "arrstack_secret_backend" {
+  description = "Map of arrstack secret engines to create (mount + config). The arrproxy admin token is read from KV"
+  type = map(object({
+    plugin                  = optional(string, "vault-plugin-secrets-arrstack")
+    description             = optional(string)
+    base_url                = string
+    ca_cert                 = optional(string)
+    request_timeout_seconds = optional(number, 30)
+  }))
+  default = {}
+}
+
+variable "arrstack_secret_backend_role" {
+  description = "Map of arrstack roles to create"
+  type = map(object({
+    name    = string
+    backend = string
+    apps    = list(string)
+    ttl     = optional(number)
+    max_ttl = optional(number)
+  }))
+  default = {}
+}
+
 variable "plugins" {
   description = "Map of plugins to import (register) in the catalog, keyed by catalog name"
   type = map(object({
@@ -415,6 +440,88 @@ variable "gitea_secret_backend_role" {
   default = {}
 }
 
+variable "netbox_secret_backend" {
+  description = "Map of netbox token secret engines to create (mount + config; seeded admin token read from KV)"
+  type = map(object({
+    plugin                  = optional(string, "vault-plugin-secrets-netbox")
+    description             = optional(string)
+    netbox_url              = string
+    token_version           = optional(number, 2)
+    ca_cert                 = optional(string)
+    tls_skip_verify         = optional(bool, false)
+    request_timeout_seconds = optional(number, 30)
+    # Pre-existing NetBox superuser (or add_user + add_token + grant_token) the
+    # engine mints an ephemeral user-admin token for, so netbox_user_management
+    # authenticates with a Vault-minted credential derived from the single static
+    # admin token instead of a second static one. Unset = use the static
+    # admin_token directly (bootstrap/degraded; breaks after admin-token rotation).
+    user_mgmt_username = optional(string)
+  }))
+  default = {}
+}
+
+variable "netbox_secret_backend_role" {
+  description = "Map of netbox engine roles; each role's filename-derived name is both the engine role and the NetBox username it mints tokens for, and its permissions block is the user's object-permission set"
+  type = map(object({
+    name            = string
+    backend         = string
+    netbox_username = optional(string)
+    netbox_user_id  = optional(number)
+    write_enabled   = optional(bool, false)
+    description     = optional(string)
+    ttl             = optional(number)
+    max_ttl         = optional(number)
+    active          = optional(bool, true)
+    staff           = optional(bool, false)
+    email           = optional(string)
+    permissions = optional(list(object({
+      name         = optional(string)
+      object_types = list(string)
+      actions      = optional(list(string), ["view", "add", "change", "delete"])
+      constraints  = optional(string)
+      description  = optional(string)
+      enabled      = optional(bool, true)
+    })), [])
+  }))
+  default = {}
+}
+
+variable "netbox_backend_aliases" {
+  description = "Map of netbox backend names to sanitized provider aliases"
+  type        = map(string)
+  default     = {}
+}
+
+variable "ghp_secret_backend" {
+  description = "Map of ghp token secret engines to create (mount + config; seeded service token read from KV)"
+  type = map(object({
+    plugin                  = optional(string, "vault-plugin-secrets-ghp")
+    description             = optional(string)
+    base_url                = string
+    ca_cert                 = optional(string)
+    tls_skip_verify         = optional(bool, false)
+    request_timeout_seconds = optional(number, 30)
+  }))
+  default = {}
+}
+
+variable "ghp_secret_backend_role" {
+  description = "Map of ghp engine roles; reading ghp/creds/<name> mints a short-lived scoped ghp token"
+  type = map(object({
+    name            = string
+    backend         = string
+    token_type      = optional(string)
+    installation_id = optional(number)
+    app_record_id   = optional(string)
+    repositories    = optional(list(string))
+    scopes          = optional(list(string))
+    session_prefix  = optional(string)
+    ttl             = optional(number)
+    max_ttl         = optional(number)
+  }))
+  default = {}
+}
+
 variable "policy_auth_map" {
   description = "Map of auth mounts -> auth roles -> policy names"
   type        = map(map(list(string)))

policies/arrstack/admin.yaml

@@ -0,0 +1,27 @@
+# Allow management of the arrstack secrets engine (config and roles) by the
+# terraform-vault deployer.
+---
+rules:
+  - path: "arrstack/config"
+    capabilities:
+      - create
+      - update
+      - read
+      - delete
+  - path: "arrstack/roles/*"
+    capabilities:
+      - create
+      - update
+      - delete
+      - read
+      - list
+  - path: "arrstack/roles"
+    capabilities:
+      - read
+      - list
+
+auth:
+  approle:
+    - tf_vault
+  k8s/au/syd1:
+    - woodpecker_terraform_vault

policies/arrstack/creds/prowlarr.yaml

@@ -0,0 +1,12 @@
+# Allow the terraform-prowlarr run to mint a Prowlarr-scoped arrproxy key.
+---
+rules:
+  - path: "arrstack/creds/prowlarr"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - terraform_prowlarr
+  k8s/au/syd1:
+    - woodpecker_terraform_prowlarr

policies/arrstack/creds/radarr.yaml

@@ -0,0 +1,12 @@
+# Allow the terraform-radarr run to mint a Radarr-scoped arrproxy key.
+---
+rules:
+  - path: "arrstack/creds/radarr"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - terraform_radarr
+  k8s/au/syd1:
+    - woodpecker_terraform_radarr

policies/arrstack/creds/sonarr.yaml

@@ -0,0 +1,12 @@
+# Allow the terraform-sonarr run to mint a Sonarr-scoped arrproxy key.
+---
+rules:
+  - path: "arrstack/creds/sonarr"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - terraform_sonarr
+  k8s/au/syd1:
+    - woodpecker_terraform_sonarr

policies/consul_root/au/syd1/creds/terraform-infra.yaml

@@ -0,0 +1,11 @@
+---
+rules:
+  - path: "consul_root/au/syd1/creds/terraform-infra"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - terraform_infra
+  k8s/au/syd1:
+    - woodpecker_terraform_infra

policies/ghp/admin.yaml

@@ -0,0 +1,37 @@
+# Allow the vault deployer to manage the ghp token secrets engine: its
+# connection config (seeded service token) and its token-minting roles.
+#
+# Scoped to ghp/* only, and deliberately excludes ghp/creds/* - minting tokens
+# is for consumers, not the deployer. ghp has NO rotate endpoint, so unlike the
+# gitea/netbox engines there is no config/rotate grant here. The plugin-catalog
+# grant needed to import the plugin is the shared, sudo-protected wildcard in
+# policies/sys/plugins/catalog/admin.yaml (already covers this plugin), and
+# mounting the engine uses the deployer's existing sys/mounts/* access, so no
+# new catalog/mount grant is added here (mirrors the gitea/netbox engines).
+---
+rules:
+  # Engine connection config (base_url, TLS, seeded service token).
+  - path: "ghp/config"
+    capabilities:
+      - create
+      - read
+      - update
+      - delete
+  # Token-minting roles.
+  - path: "ghp/roles/*"
+    capabilities:
+      - create
+      - read
+      - update
+      - delete
+      - list
+  - path: "ghp/roles"
+    capabilities:
+      - read
+      - list
+
+auth:
+  approle:
+    - tf_vault
+  k8s/au/syd1:
+    - woodpecker_terraform_vault

policies/ghp/creds/agent.yaml

@@ -0,0 +1,13 @@
+# Lets the agents AppRole mint ephemeral ghp agent tokens, so AI coding agents
+# authenticate to ghp as their own short-lived, least-privilege identity.
+# Reading ghp/creds/agent returns a lease-bound token scoped by the role
+# (token_type agent, contents:read). Mirrors the gitea/creds/unkin-agent binding.
+---
+rules:
+  - path: "ghp/creds/agent"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - agents

policies/gitea/creds/unkin-agent.yaml

@@ -0,0 +1,14 @@
+# Lets the agents AppRole mint ephemeral Gitea tokens for the unkin-agent bot,
+# so AI coding agents authenticate to git.unkin.net as their own least-privilege
+# identity instead of Ben's account. Reading gitea/creds/unkin-agent returns a
+# lease-bound token scoped by the role (write:repository, write:issue, read:user
+# -- never merge/admin). Mirrors the agent-* Kubernetes creds binding pattern.
+---
+rules:
+  - path: "gitea/creds/unkin-agent"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - agents

policies/kubernetes/au/syd1/creds/agent-certs.yaml

@@ -0,0 +1,12 @@
+# Allow access to agent-certs Kubernetes credentials
+---
+rules:
+  - path: "kubernetes/au/syd1/creds/agent-certs"
+    capabilities:
+      - update
+
+auth:
+  ldap:
+    - kubernetes_au_syd1_cluster_operator
+  approle:
+    - agents

policies/kubernetes/au/syd1/creds/agent-dhcp.yaml

@@ -0,0 +1,12 @@
+# Allow access to agent-dhcp Kubernetes credentials
+---
+rules:
+  - path: "kubernetes/au/syd1/creds/agent-dhcp"
+    capabilities:
+      - update
+
+auth:
+  ldap:
+    - kubernetes_au_syd1_cluster_operator
+  approle:
+    - agents

policies/kubernetes/au/syd1/creds/agent-dns.yaml

@@ -0,0 +1,12 @@
+# Allow access to agent-dns Kubernetes credentials
+---
+rules:
+  - path: "kubernetes/au/syd1/creds/agent-dns"
+    capabilities:
+      - update
+
+auth:
+  ldap:
+    - kubernetes_au_syd1_cluster_operator
+  approle:
+    - agents

policies/kubernetes/au/syd1/creds/agent-storage.yaml

@@ -0,0 +1,12 @@
+# Allow access to agent-storage Kubernetes credentials
+---
+rules:
+  - path: "kubernetes/au/syd1/creds/agent-storage"
+    capabilities:
+      - update
+
+auth:
+  ldap:
+    - kubernetes_au_syd1_cluster_operator
+  approle:
+    - agents

policies/kv/kubernetes/agents.yaml

@@ -0,0 +1,17 @@
+# Allow the agents AppRole to manage the kubernetes KV subtree (no delete)
+---
+rules:
+  - path: "kv/data/kubernetes/*"
+    capabilities:
+      - create
+      - read
+      - update
+      - list
+  - path: "kv/metadata/kubernetes/*"
+    capabilities:
+      - read
+      - list
+
+auth:
+  approle:
+    - agents

policies/kv/kubernetes/namespace/arrstack/default/arrproxy-admin-token/read.yaml

@@ -0,0 +1,22 @@
+# Allow the terraform-vault deployer to read the seeded arrproxy admin token so
+# the arrstack engine config module can source it. The token is seeded by
+# argocd-apps #384 at kv/kubernetes/namespace/arrstack/default/arrproxy-admin-token.
+# The deployer's existing secret_backends_read policy only covers
+# kv/data/service/vault/+/+/secret_backend/*, which does not match this
+# kubernetes/namespace path, so this adds the minimal read grant rather than
+# duplicating the secret into the litellm-style path. vault_kv_secret_v2 also
+# reads the kv-v2 metadata path on every plan/apply, so grant that too.
+---
+rules:
+  - path: "kv/data/kubernetes/namespace/arrstack/default/arrproxy-admin-token"
+    capabilities:
+      - read
+  - path: "kv/metadata/kubernetes/namespace/arrstack/default/arrproxy-admin-token"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - tf_vault
+  k8s/au/syd1:
+    - woodpecker_terraform_vault

policies/kv/service/terraform/infra.yaml

@@ -0,0 +1,18 @@
+# Allow the terraform-infra runner to read the NetBox + KeaAPI tokens
+# (netbox_token / kea_token fields) used by the netbox and kea providers.
+---
+rules:
+  - path: "kv/data/service/terraform/infra"
+    capabilities:
+      - read
+  # vault_kv_secret_v2 (terraform-infra providers.tf data source) reads the kv-v2
+  # metadata path on every plan/apply; a 403 here fails the plan.
+  - path: "kv/metadata/service/terraform/infra"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - terraform_infra
+  k8s/au/syd1:
+    - woodpecker_terraform_infra

policies/netbox/admin.yaml

@@ -0,0 +1,42 @@
+# Allow the vault deployer to manage the netbox token secrets engine: its
+# connection config (seeded admin token), in-place token rotation, and
+# token-minting roles.
+#
+# Scoped to netbox/* only, and deliberately excludes netbox/creds/* - minting
+# tokens is for consumers, not the deployer. The plugin-catalog grant needed to
+# import the plugin is the shared, sudo-protected wildcard in
+# policies/sys/plugins/catalog/admin.yaml (already covers this plugin), and
+# mounting the engine uses the deployer's existing sys/mounts/* access, so no
+# new catalog/mount grant is added here (mirrors the gitea/rancher engines).
+---
+rules:
+  # Engine connection config (NetBox URL, TLS, token_version, seeded admin token).
+  - path: "netbox/config"
+    capabilities:
+      - create
+      - read
+      - update
+      - delete
+  # In-place rotation of the seeded admin token (write-only trigger).
+  - path: "netbox/config/rotate"
+    capabilities:
+      - create
+      - update
+  # Token-minting roles.
+  - path: "netbox/roles/*"
+    capabilities:
+      - create
+      - read
+      - update
+      - delete
+      - list
+  - path: "netbox/roles"
+    capabilities:
+      - read
+      - list
+
+auth:
+  approle:
+    - tf_vault
+  k8s/au/syd1:
+    - woodpecker_terraform_vault

policies/netbox/creds/terraform-infra.yaml

@@ -0,0 +1,21 @@
+# Allow the terraform-infra runner to mint an ephemeral NetBox token from the
+# terraform-infra role (netbox/creds/terraform-infra), replacing the static
+# netbox_token it used to read from kv/service/terraform/*. The e-breuninger
+# netbox provider authenticates with the minted token; the lease revokes it when
+# the run ends.
+#
+# Bound to both the terraform-infra AppRole and its Woodpecker k8s auth role,
+# mirroring the terraform-ipam pattern. Both principals are created by the
+# terraform-infra Vault onboarding (separate from this netbox change); until
+# that onboarding lands this policy exists but attaches to nothing.
+---
+rules:
+  - path: "netbox/creds/terraform-infra"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - terraform_infra
+  k8s/au/syd1:
+    - woodpecker_terraform_infra

policies/netbox/creds/vault-user-mgmt.yaml

@@ -0,0 +1,23 @@
+# Allow the vault deployer to mint the ephemeral user-admin token that
+# netbox_user_management authenticates with (netbox/creds/vault-user-mgmt). The
+# engine mints it from the single static admin token, so the deployer never holds
+# a second static NetBox credential.
+#
+# The netbox admin policy (policies/netbox/admin.yaml) deliberately excludes
+# netbox/creds/* - minting is normally for consumers, not the deployer. This is
+# the one deliberate exception: the deployer needs a user-admin token during the
+# run to reconcile NetBox users. Scoped to the single vault-user-mgmt role only.
+#
+# Bound to the same principals as the admin policy: the tf_vault AppRole and its
+# Woodpecker k8s auth role.
+---
+rules:
+  - path: "netbox/creds/vault-user-mgmt"
+    capabilities:
+      - read
+
+auth:
+  approle:
+    - tf_vault
+  k8s/au/syd1:
+    - woodpecker_terraform_vault

resources/secret_backend/consul_root/au/syd1/terraform-infra.hcl

@@ -0,0 +1,7 @@
+key_prefix "infra/terraform/infra/" {
+  policy = "write"
+}
+
+session_prefix "" {
+  policy = "write"
+}

resources/secret_backend/kubernetes/au/syd1/roles/agent-certs.yaml

@@ -0,0 +1,33 @@
+---
+rules:
+  - apiGroups:
+      - "cert-manager.io"
+      - "acme.cert-manager.io"
+    resources:
+      - "*"
+    verbs:
+      - "*"
+  - apiGroups:
+      - ""
+    resources:
+      - "secrets"
+    verbs:
+      - "get"
+      - "list"
+      - "watch"
+      - "delete"
+  - apiGroups:
+      - ""
+    resources:
+      - "pods"
+    verbs:
+      - "get"
+      - "list"
+      - "watch"
+  - apiGroups:
+      - ""
+    resources:
+      - "pods/log"
+    verbs:
+      - "get"
+      - "list"

resources/secret_backend/kubernetes/au/syd1/roles/agent-dhcp.yaml

@@ -0,0 +1,26 @@
+---
+rules:
+  - apiGroups:
+      - "kea.unkin.net"
+    resources:
+      - "*"
+    verbs:
+      - "*"
+  - apiGroups:
+      - ""
+    resources:
+      - "pods"
+      - "services"
+      - "configmaps"
+      - "events"
+    verbs:
+      - "get"
+      - "list"
+      - "watch"
+  - apiGroups:
+      - ""
+    resources:
+      - "pods/log"
+    verbs:
+      - "get"
+      - "list"

resources/secret_backend/kubernetes/au/syd1/roles/agent-storage.yaml

@@ -0,0 +1,23 @@
+---
+rules:
+  - apiGroups:
+      - "ceph.unkin.net"
+    resources:
+      - "*"
+    verbs:
+      - "*"
+  - apiGroups:
+      - ""
+    resources:
+      - "pods"
+    verbs:
+      - "get"
+      - "list"
+      - "watch"
+  - apiGroups:
+      - ""
+    resources:
+      - "pods/log"
+    verbs:
+      - "get"
+      - "list"