Skip to content
SHC Docs

The tenant model, should SHC's product infrastructure live in its own tenant (proposal)

Status: open design. The move into an shc tenant is not ruled, and nothing has been migrated.

Written 2026-08-15. Read first-hand against ce at 2fd655b2 and shc at aff27f615 (both main, both 63 behind origin/main; both working trees carry another lane’s uncommitted work, which this document did not touch and did not read for facts). Every live fact below was measured read-only on the two production estates running 0.0.57-SNAPSHOT-a7d0422c0: promanager ([email protected]) and bitspur ([email protected]). The one command issued that could have mutated anything was a --dry-run, and it refused before planning; the transcript is in the defect.

The owner’s framing:

“shouldn’t all of the BitSpur/selfhosted-cloud stuff go in a tenant called SHC?”

And the ruling that authorised execution:

“That’s okay. I don’t care if anything gets reset in these SHC tenant [stacks].”

This document recommends that the migration NOT be executed today, and the reason is not the architecture; the architecture argument is good. The reason is that the cheap, non-lossy path (shc move --target-tenant) exists, is genuinely built for this, and is broken by one line; and that one of the four stacks nominated for the move is fused to the owner’s live mail. Spending the data-loss budget the ruling granted, on a migration a one-line fix makes lossless, would be a bad trade made under a ruling that was written before either fact was known.


A tenant is not one thing. It is nine things that happen to share a name, and the name is load-bearing in all nine.

1.1 It is a Keycloak realm, literally, one-to-one

Section titled “1.1 It is a Keycloak realm, literally, one-to-one”

core/validation/reserved_names.go:

“Tenant names also become Keycloak realm names today; Keycloak’s own realm-naming constraint is a superset of these rules, so callers don’t need a separate realm-name check.”

modules/auth/keycloak_admin.go, on why the deny role is spelled tenant:deny and not tenant:<name>:deny:

“a realm IS a tenant, roles resolve only in the token’s own realm, so a role in realm A naming tenant B would be unenforceable by construction and would create a second, lying source of truth for tenancy. Cross-realm deny is not expressible.”

Users, groups, role mappings and the shc-access / shc-forward-auth clients all live inside one realm. There is no cross-realm anything.

The browser login path closes the loop. modules/auth/router.go, oidcRealmForHostHandler: the forward-auth sidecar asks “what realm serves this hostname?”, and the answer is the tenant of the deployment that owns the host:

mapping, ok, err := resolver(r.Context(), cleanHost)
if err == nil && ok {
realm := mapping.TenantName

So a stack’s tenant decides which realm its users authenticate against, per HTTP request, resolved at login time from the deployment row. Change the row’s tenant and every human who logs into that hostname is sent to a different realm tomorrow morning.

Measured on promanager: the corp realm holds four users, and every one of them carries stack:license-broker:use and stack:pulp:use:

USERNAME EMAIL ENABLED ROLES
clayrisser [email protected] true stack:affine-rs:use, …, stack:license-broker:use, …, stack:pulp:use, …
henry [email protected] true stack:affine-rs:use, …, stack:license-broker:use, …, stack:pulp:use, …
nc-sso-smoke [email protected] true …
shc-vfy9 [email protected] true …

Note the DIRECT_ROLES column: for clayrisser it lists only three roles, and for the other three users it is -. Everything else is inherited from a group mapping in the corp realm. A new shc realm starts with no users, no group, and no mappings. Nothing in shc move or shc install recreates them.

1.2 It is a Docker Compose project name prefix

Section titled “1.2 It is a Docker Compose project name prefix”

modules/app/install_runner.go:

func DockerProjectName(tenant, environment, stack string) string {
joined := tenant + "_" + environment + "_" + stack
return strings.NewReplacer("-", "_", ".", "_", " ", "_").Replace(joined)
}

with the warning attached:

“Changing this function’s output would rename the project of every stack already running on every host and orphan their containers from the CLI.”

Renaming the tenant of a running stack renames its compose project, which renames its containers, its default network and its named volumes. This is why a tenant change can never be a metadata update. It is a teardown and a re-creation of the container-level identity, whatever verb wraps it.

modules/app/install_runner.go: DeploymentDir(stateHome, tenant, stack, env) → <state>/deployments/<tenant>/<stack>/<env>/, holding the rendered compose, the app/ tree, state.json and mounts/.

modules/backup/encryption.go: archives land at <state>/backups/<tenant>/<stack>/, “still not configurable”.

1.4 It is a vault path prefix and a cascade tier

Section titled “1.4 It is a vault path prefix and a cascade tier”

modules/vault/service.go describes the real paths: shc/tenants/<t>/admin_password, and shc/tenants/<t>/stacks/<stack>/environments/<env>/….

modules/vault/models.go:GetScope gives the five tiers, Global → Tenant → Stack → Environment → Deployment, and reads resolve down the cascade, preferring the narrowest tier that has a row. A stack in tenant A reading a tenant-tier secret gets A’s row; the same stack in tenant B gets B’s, or falls through to Global if B has none.

modules/vault/service.go:RenameSecrets(ctx, tenant, source, target, _) moves secrets between stack names within one tenant. There is no cross-tenant equivalent. (The move path does not need one; see §3.4.)

1.5 It is a Traefik router / ingress-file / middleware name

Section titled “1.5 It is a Traefik router / ingress-file / middleware name”

Measured on promanager (SHC_TENANT=corp shc ingress ls):

FILE ROUTER HOST GATE
ingress-corp_prod_license_broker.yaml corp_prod_license_broker license.corp.promanager.vip shc-launcher-corp_prod_license_broker
ingress-corp_prod_pulp.yaml corp_prod_pulp artifacts.corp.promanager.vip shc-launcher-corp_prod_pulp

The hostname is not derived from the tenant; it is whatever the operator passed to --host, and it survives a move (§3.3). But the ingress file, the router, the service and the launcher gate middleware are all <tenant>_<env>_<stack>, so all four are renamed by a tenant change.

shc/traefik/render/render.go also fixes the platform’s own coordinates:

systemTenant = "master"
systemEnv = "default"
systemRouterPriority = 100000 // "out-ranks any tenant router that matches the same host"

1.6 It is the unit of authorisation and the IDOR boundary

Section titled “1.6 It is the unit of authorisation and the IDOR boundary”

modules/auth/types.go: User.CanAccessTenant compares tenantName == u.TenantName; “Cross-tenant access is granted only through platform:manage.” modules/user/service.go:ResolveTargetTenant: a tenant admin is pinned to their own tenant (X403931USRXTN); only a platform admin may name another. modules/quota/router.go gates every read on the exact resolved tenant.

1.7 It is a config scope tier, a connection key, a CA owner and a DNS grant

Section titled “1.7 It is a config scope tier, a connection key, a CA owner and a DNS grant”
  • Config: five tiers, global → tenant → environment → stack → deployment, with tenant rows keyed on tenant_name (modules/config/).
  • Connections: identity is (tenant_name, name), the schema’s unique index (modules/connections/repository.go). Measured on bitspur: hcloud is owned by tenant master; aws and hetzner-s3 by default.
  • CA: shc ca provision -t <tenant>, a per-tenant intermediate.
  • DNS: dns.grants.<tenant>.<provider>, global scope only, and modules/dns/socketgrant.go is blunt about the asymmetry: “The master tenant holds every provider implicitly; every other tenant needs the master tenant’s operator to run shc config set dns.grants.<tenant>.<provider> true.”

1.8 It is the scope of a collector and of backup listing

Section titled “1.8 It is the scope of a collector and of backup listing”

Per-tenant scoped collectors are minted at daemon start and on tenant.created / tenant.deleted (modules/tenant/types.go, decision B9); modules/metrics/collectors/aggregate.go carries a tenantFilter narrowing every rollup tier. Backup rows are indexed (tenant_name, stack_name) and shc backup ls filters by the active tenant; --all-tenants is the escape hatch, and modules/backup/daemon_client.go records the bug that taught them that:

“POSTed the create WITH the tenant (so the row landed in corp), then … applied its tenant filter, and the CLI reported [X404400BKPNOF] backup not found”

1.9 It is a licensed capability with a counted cap

Section titled “1.9 It is a licensed capability with a counted cap”

shc/modules/tenant/create_gate.go gates creation on the tenancy entitlement; create_count_gate.go enforces max_tenants, counting additional tenants (excluding default and master). Measured on promanager:

state: keyed
tier: internal
features: … tenancy …
capacity:
licensed: max_nodes=unlimited max_seats=unlimited max_tenants=unlimited
now: max_nodes=4 max_cores=64 max_seats=6 max_tenants=2

Creating shc is licensed on both estates. This is not a blocker.

1.10 The one category the code already has: master

Section titled “1.10 The one category the code already has: master”

This is the most important prior art for the owner’s question, and it deserves its own heading because SHC already has a product-infrastructure tenant.

modules/tenant/master_reserved.go:

“master is SHC’s own realm and its own tenant: the platform stacks (postgres, keycloak, traefik, openobserve) deploy at tenant=master, SHC’s own operators authenticate against the master Keycloak realm, and the inbound realm→tenant reconcile EXCLUDES master deliberately because it is infrastructure, not a customer.”

master is hard-reserved; the check runs unconditionally, ahead of the edition gate and out of reach of the Internal bypass. Measured, master holds exactly what the doc says on both estates:

promanager master: bitspur master:
keycloak keycloak
openobserve openobserve
postgres postgres
traefik traefik
keycloak/cloud (realm plug)

And master is privileged in three more places: it holds every DNS provider grant implicitly, it is skipped by the tenant cap, and it is the only tenant reachable across the tenant boundary by an integration (§2.3).

So the code’s tenant taxonomy today is two-valued: master (the control plane SHC itself runs on) and “a customer”. There is no third slot for “the vendor’s own product-serving infrastructure”, which is exactly what the owner is asking for. An shc tenant would be an operator convention layered on the customer category, not a category the code recognises.


Measured on promanager, corp holds 44 stacks; bitspur’s corp holds 75 deployments (62 top-level + 13 plug/sub-deployments). The two lifecycles the owner identified are real and they are in one realm:

kindpromanagerbitspur
SHC product infrastructure: must be reproducible on any estatekeygen, keygen-db, license-broker, identity-broker, identity-broker-db, pulp, pulp-db, pulp-s3same, plus the vendor broker itself
BitSpur business operations: the company’s own data, unique, irreplaceablenc (+nc-db), penpot, fleet, dtrack, matrix, huly, gitlab, sonarqube, wazuh, windmill, ciso, glitchtip, uptime-kuma, affine-rs, crowdsec, minio, openreplayall of the above plus mailcow (live mail), mautic, erpnext/ffx/bit (frappe), librechat, midpoint, ollama, openhands, marketplace, mailbox-reconciler

The lifecycle argument is sound. Product infrastructure should be shc uninstall && shc install-able on a scratch estate as a release artifact; business operations should never be. Sharing a realm means they share one set of users, one group, one CA, one DNS grant set and one blast radius.

2.2 The argument AGAINST an shc tenant, stated fairly

Section titled “2.2 The argument AGAINST an shc tenant, stated fairly”

Three real costs:

  1. A tenant is a realm, and a realm is a login. Splitting the tenant splits the login. Clay and Henry would hold accounts in corp and shc, with two password/2FA registrations and two group memberships to keep in sync, for an estate with six seats. master avoids this because nobody logs into postgres or traefik through a browser gate, but license.corp.promanager.vip and artifacts.corp.promanager.vip are browser surfaces behind shc-launcher-* gates.
  2. The boundary is closed to integrations. §2.3; this is the hard one.
  3. It is a convention, not a category. Nothing in the code will keep shc pure. The next shc install run with the wrong -t puts a business app in it, and no gate objects. The master reservation works because it is enforced in one unconditional function; an shc tenant has no such function and would need one written to mean anything durable.

2.3 ★ The constraint that decides the shape of any split

Section titled “2.3 ★ The constraint that decides the shape of any split”

modules/app/integration_magic.go:

“integration_magic.go implements the ONLY sanctioned cross-tenant integration path: a closed allowlist of system-namespace, critical-dependency providers that live once in the master tenant… Every OTHER integration stays confined to the consumer’s own tenant.”

The allowlist has exactly one row:

var magicProviders = []magicProvider{
{Token: "KEYCLOAK", Stack: "keycloak", OverrideField: "realm"},
}

Therefore: a set of stacks may only be moved into a new tenant if its integration closure is entirely inside that set (plus KEYCLOAK). Any edge that would cross the new boundary is not expressible, in either direction.

Measured integration graphs on promanager (shc integration ls -t corp -e prod):

=== keygen ===
keygen postgres keygen-db postgres post_deployed
license-broker keygen keygen keygen post_deployed
=== pulp ===
pulp postgres pulp-db postgres post_deployed
pulp s3 pulp-s3 s3 post_deployed
=== identity-broker ===
huly-nextcloud identityBroker identity-broker identityBroker post_deployed
identity-broker nextcloud nc nextcloud post_deployed
identity-broker oidc keycloak oidc post_deployed
identity-broker postgres identity-broker-db postgres post_deployed

and on bitspur, where it is far worse:

=== identity-broker ===
huly identityBroker identity-broker identityBroker post_deployed
huly-nextcloud identityBroker identity-broker identityBroker post_deployed
identity-broker mailcow mailcow mailcow post_deployed
identity-broker matrixAdmin matrix matrixAdmin post_deployed
identity-broker midpoint midpoint midpoint post_deployed
identity-broker nextcloud nc nextcloud post_deployed
identity-broker oidc keycloak oidc post_deployed
identity-broker postgres identity-broker-db postgres post_deployed

So the nominated four split cleanly into three verdicts:

setmembersclosureverdict
Alicense-broker → keygen → keygen-dbclosedmovable
Bpulp → {pulp-db, pulp-s3}closedmovable
Cidentity-broker → identity-broker-dbNOT closed: consumes nc, mailcow, matrix, midpoint; consumed by huly, huly-nextcloudNOT MOVABLE. It is the estate’s identity fabric, wired into the owner’s live mail.

gitlab was named on both sides of the brief that commissioned this document. It is resolved here conservatively as business, stays put; it holds the company’s source history, and it has no closed product-infra closure.

Split, but along the closure lines the code permits, and only after the move verb is fixed. Concretely:

  • Create tenant shc for the reproducible product plane: Set A and Set B. These are the two sets that are genuinely release artifacts, the licensing chain and the artifact repository, and both are closed.
  • Leave identity-broker in corp. It is not product infrastructure in the lifecycle sense the owner means; it is the estate’s identity integration fabric, and its whole job is to touch the business apps.
  • Leave master exactly as it is. Do not attempt to fold product infrastructure into master: master is hard-reserved, its create path is closed, and the platform relies on master holding only the four control-plane stacks (traefik/render/render.go pins systemTenant = "master" and gives its routers priority 100000).
  • If the shc tenant is to mean something durable, add a real gate, the master_reserved.go shape, one unconditional function, rather than relying on operators remembering -t.

3. What a cross-tenant move entails, per subsystem

Section titled “3. What a cross-tenant move entails, per subsystem”

shc move has a --target-tenant flag, verified far-side on the live promanager binary:

Usage:
shc move <source> <target> [flags]
Flags:
--target-environment string target environment
--target-tenant string target tenant

And the implementation is not a stub. It is genuinely built for this. Here is what each subsystem does, and what breaks if the step is missed.

3.1 Strategy selection: a cross-tenant move is ALWAYS heavy

Section titled “3.1 Strategy selection: a cross-tenant move is ALWAYS heavy”

modules/clone/service.go:

“A deployment-move fast strategy (ephemeral / rebind) is eligible ONLY for a same-tenant, same-env, same-name relocation… A cross-tenant / cross-env / rename move changes the deployment identity + on-disk dirs + vault secrets, so it always takes backup+restore.”

So the mechanism is: back up each stack → stop → restore into the target scope → bring up → uninstall the source. There is no in-place metadata flip, and there could not be; §1.2.

tenantmod.RequireKnown(ctx, targetTenant) runs in preflight. Step: shc tenant add shc first. Missed → the move refuses before touching anything (read-only preflight, so this failure is free).

3.3 On-disk, compose project, ingress, posture: carried

Section titled “3.3 On-disk, compose project, ingress, posture: carried”
  • <state>/deployments/corp/… → <state>/deployments/shc/…, re-rendered.
  • compose project corp_prod_license_broker → shc_prod_license_broker; containers, network and volumes re-created under the new project.
  • Ingress hosts are replayed; daemon/services_clone_remote.go reads them from the restored state.json, falls back to the cluster-replicated host_mapping rows, and passes them back into ExecuteCompose so injectTraefikIngress re-attaches the __shc_ingress overlay. Missed → “the moved container joins only its node-local _default bridge and the system Traefik 502s it cross-node”.
  • Access posture is replayed from the replicated row (rowAccess, rowExposure). Missed → “silently DOWNGRADING a --gated app to open on move; the forward-auth middleware vanishes from the regenerated route.”
  • The app identity is read off the restored manifest, not the stack name, the fix for the measured promanager 2026-08-09 bug where keygen-db’s app_name went postgres → keygen-db.
  • An absent app/ tree after restore is a hard failure, not an empty success, the fix for the move that “DESTROYS THE SOURCE, and reports the move a success, with no container anywhere”.

3.4 Vault: carried and correctly re-scoped

Section titled “3.4 Vault: carried and correctly re-scoped”

daemon/backup_seam_adapters.go, DaemonBackupVaultImporter.Import:

_, err := svc.Import(ctx, data, vault.ImportOptions{
TargetTenant: req.TenantName,
TargetStack: req.StackName,
TargetEnvironment: req.Environment,
Overwrite: true,
RemapScope: true,
})

“RemapScope is forced true so every imported row is PINNED to the restore target scope… never the plaintext scope columns the backup bundle carries.”

So shc/tenants/corp/stacks/license-broker/… is rewritten to shc/tenants/shc/stacks/license-broker/…. This subsystem is done correctly and needs no operator step. Note the one exception: connection-credential keys are deliberately skipped by import (IsConnectionCredKey); those must be re-provisioned with shc connection connect.

3.5 Keycloak: NOT carried. This is the gap.

Section titled “3.5 Keycloak: NOT carried. This is the gap.”

grep -rn "realm\|sso\|grant" modules/clone/ returns four hits, all of them comments. The clone/move subsystem never contacts Keycloak.

What that means concretely for Set A + Set B on promanager:

  1. shc tenant add shc provisions a new, empty shc realm (ProvisionTenantRealm, realm + shc-access client + canonical roles).
  2. The moved deployments’ stack:<name>:use roles are created in the shc realm by the reconcile, but no user holds them.
  3. license.corp.promanager.vip now resolves, at login, to realm shc (§1.1). Clay’s corp account and its group-inherited stack:license-broker:use are in the wrong realm and cannot be made to apply; “Cross-realm deny is not expressible”, and neither is cross-realm grant.
  4. Missed → every human is locked out of the moved surfaces, with a perfectly healthy container behind the gate.

Required operator steps, per moved tenant: shc user create for each of the 4 corp users in shc, recreate the group that carries the inherited roles, re-grant, and have each user re-register credentials. There is no export/import for this.

3.6 Backups, config, connections, CA, DNS grants: NOT carried

Section titled “3.6 Backups, config, connections, CA, DNS grants: NOT carried”

None of these follow the deployment row:

subsystemkeyed byafter a movefix
backup rows + archives(tenant_name, stack_name), <state>/backups/<tenant>/<stack>/pre-move archives stay under corp; shc backup ls in shc shows none--all-tenants to find them; the restore-safety net is not lost, just not where you will look for it
config rows at tenant tiertenant_nameshc inherits only global-tier valuesre-set any tenant-tier override
connections(tenant_name, name) unique indexa stack in shc cannot resolve a corp connectionshc connection connect in shc
CAper-tenant intermediateshc has noneshc ca provision -t shc if edge trust is used
DNS grantsdns.grants.<tenant>.<provider>, global scopeshc is granted nothingshc config set dns.grants.shc.hcloud true, must be written by the master-tenant operator, never self-granted
per-tenant collectortenant filternew scoped collector minted on tenant.createdautomatic
  • A scope-changing move may not carry an off-scope member: X400630CLNXSC, refused in read-only preflight. Both Set A and Set B are scope-uniform (corp/prod), so this does not bite.
  • A depth-2 chain needs --closure, not just -a. The code names our exact case: “a real dependency chain is three or four deployments (license-broker -> keygen -> keygen-db)”, and -a alone carries only one hop, leaving keygen-db behind; “keygen arrives on the target with no database.”
  • --closure is bounded at 8 stacks (moveClosureMaxStacks). Set A is 3, Set B is 3. Fine.

3.8 ★ A latent guard hole, found while reading this path

Section titled “3.8 ★ A latent guard hole, found while reading this path”

modules/clone/service.go, preflight:

sameNode := targetNode == source.Node // targetNode defaults to source.Node when no --node
…
if hasDeps {
if cctx.AllConnections {
…
if !sameNode {
if stranded, serr := s.peersOutsideTheMove(ctx, stacks); … {
return result, X400600CLNCON(strings.Join(stranded, ", "))
}
}
} else if !sameNode {
return result, X400600CLNCON(source.Name)
}
}

Both integration guards, “you did not pass -a” and “your -a set is not closed”, are gated on !sameNode. A cross-tenant move that does not change node skips both. Every product-infra stack on promanager sits on the same node (node-b07d3a61747e), so the intended migration is exactly the shape that walks past the guards: shc move license-broker license-broker --target-tenant shc would be planned with no complaint and would strand keygen in corp, producing an integration edge across a boundary the magic-token allowlist says cannot exist.

sameNode is the wrong predicate. The predicate the guards want is “does this move change the scope key at all”: node or tenant or environment. This is not currently reachable (§4 explains why), which is the only reason it has not bitten anyone.


4. The defect: cross-tenant move is unreachable

Section titled “4. The defect: cross-tenant move is unreachable”

modules/clone/service.go:Move, with its own comment two lines above the bug:

// The tenant an operator typed rides the REQUEST SCOPE (reqctx, via the
// daemonclient header), not the body; TenantName is `--target-tenant`,
// a different question.
…
if req.SourceTenant == "" {
req.SourceTenant = firstNonEmptyTenant(req.TenantName, s.tenantResolver(ctx))
}

req.TenantName is populated from --target-tenant, modules/clone/register.go:

func adaptMoveRequest(in commands.MoveArgs) StackMoveRequest {
return StackMoveRequest{
SourceStack: in.Source,
TenantName: in.TargetTenant,

The flag that names the destination is used as the first candidate for the source lookup. So the moment you pass --target-tenant, preflight goes looking for the source stack in the destination tenant, where, by definition, it is not.

Reproduced far-side on promanager, read-only (--dry-run returns after the read-only plan leg; nothing was stopped, copied or written):

$ shc move license-broker license-broker --tenant corp --environment prod --target-tenant public --dry-run
shc: [X404600CLNSRC] stack license-broker not found

The same refusal comes back with SHC_TENANT=corp SHC_ENVIRONMENT=prod, with -t corp -e prod, and with the flags in either position because the source tenant is decided by --target-tenant before any of those are consulted. The deployment is healthy and running in corp/prod throughout:

license-broker corp prod license-broker running node-b07d3a61747e

Answer to the question the brief asked: shc move CAN move a stack across tenants, the flag exists, the heavy path is built for it, vault re-scoping and ingress replay are correct, but on 0.0.57-SNAPSHOT-a7d0422c0, the build running on both production estates, no cross-tenant move can be invoked at all. The only --target-tenant value that resolves a source is the tenant the source is already in, which is a no-op.

The fix is one line, resolve SourceTenant from the request scope only, never from TenantName, plus the sameNode predicate in §3.8, plus a mutation-proof test for each. That is a small, well-bounded piece of work, not a project.


ACTIVE NAME STACKS
corp 44
* default 4
master 4
public 1

default holds Henry’s dev/test/prod ioverse and henry-test; public holds the promanager public dev app. Neither is touched by any proposal here.

Moving Set A + Set B out of corp touches:

  • 6 deployments (license-broker, keygen, keygen-db, pulp, pulp-db, pulp-s3) stopped, archived, restored, brought up, source torn down.
  • 2 public hostnames: license.corp.promanager.vip, artifacts.corp.promanager.vip. Hostnames survive; the realm behind their gate does not.
  • 4 corp-realm users, all of whom lose stack:license-broker:use and stack:pulp:use in practice (the roles remain in corp, where the hostnames no longer resolve).
  • keygen has no ingress at all; it is reachable only in-cluster by license-broker. Good: no external surface, no DNS.

5.2 bitspur, and the reason this is not a private estate

Section titled “5.2 bitspur, and the reason this is not a private estate”
ACTIVE NAME STACKS
corp 62 (75 deployments incl. plugs)
* default 0
master 4

shc/modules/license/broker.go bakes the vendor’s address into every binary ever shipped:

const DefaultBrokerURL = "https://license.selfhostedcloud.org"

“It is a FROZEN CONSUMER CONTRACT: every binary ever shipped renews from whatever hostname it was built with, and a binary in the field cannot be told a new one; that is the whole point of baking it in.”

Measured:

$ getent hosts license.selfhostedcloud.org
37.27.215.210 license.selfhostedcloud.org ← bitspur
$ ssh bitspur 'SHC_TENANT=corp shc ingress ls | grep license'
ingress-corp_prod_license_broker.yaml corp_prod_license_broker license.selfhostedcloud.org …

The vendor’s production licensing plane for every SHC estate in existence is a stack in bitspur’s corp tenant. Promanager’s license-broker (license.corp.promanager.vip, DNS → 204.168.129.34) is the provisional address the same file describes, the one ≤v0.0.11 binaries still renew from (“promanager’s broker stays live until both production estates roll v0.0.12”).

This matters for two reasons:

  1. It is the sharpest possible argument for the owner’s instinct. Product infrastructure that the whole customer base depends on should not be sitting in the tenant that also holds the company’s Nextcloud and its mail, sharing one realm, one group, one CA and one operator’s muscle memory.
  2. It changes what “downtime is fine” means. The ruling granted a data-loss budget. It did not grant a vendor-availability budget, and an uninstall+reinstall of bitspur’s license-broker is a licensing outage for every estate in the field for the duration.

identity-broker. On bitspur it consumes mailcow, the owner’s live mail, 9 mailboxes, plus matrix, midpoint and nc, and it is consumed by huly and huly-nextcloud. Six edges to business apps, in both directions. Under the one-row magic-token allowlist, none of those six edges can be expressed across a tenant boundary. Moving it does not degrade SSO; it disintegrates it.


6. Why this document does not end with a completed migration

Section titled “6. Why this document does not end with a completed migration”

The brief that commissioned it authorised uninstall+reinstall into an shc tenant for the product-infrastructure stacks on promanager, on the owner’s ruling that resetting those stacks is acceptable, and asked for the proposal first and the execution second. The proposal is written; the execution is deliberately not done. Three findings, all measured after the ruling was given, changed the trade:

  1. A non-lossy path exists and is one line from working (§4). Spending a data-loss budget on a migration that a one-line fix makes lossless is a bad trade, and the ruling was written believing no move verb existed.
  2. One of the four nominated stacks is fused to the owner’s live mail (§2.3, §5.3). The brief’s own instruction was to list and ask rather than guess when a stack’s classification is unclear; identity-broker is not unclear, it is measurably entangled, and it was on the move list.
  3. The guard that would have caught a stranded dependency is bypassed for exactly this migration’s shape (§3.8). Executing today means executing with the safety net demonstrably down.

Nothing on either estate was mutated. The estates are exactly as they were.


  1. Fix the move, or spend the data-loss budget? Fixing Move’s source-tenant resolution and the sameNode predicate is a small, testable change that makes the migration lossless and reversible. The alternative is uninstall+reinstall, which is authorised but throws away keygen’s licence records and pulp’s artifact index for no gain. Recommended: fix it.
  2. Does shc mean the two closed sets, and only those? Set A (license-broker, keygen, keygen-db) and Set B (pulp, pulp-db, pulp-s3) are the only nominated stacks whose integration closure permits a boundary. Confirm that is the scope.
  3. identity-broker stays in corp, confirm. It is identity integration fabric, not a release artifact, and on bitspur it is wired to live mail.
  4. gitlab stays in corp, confirm. It was named on both sides of the brief; it is resolved here as business.
  5. Two realms, two logins: is that acceptable for a six-seat estate? A tenant is a realm. Clay and Henry would hold accounts in both, with separate credentials and separate group memberships, to reach license.… and artifacts.…. There is no cross-realm grant. If the answer is no, the honest alternative is to leave the split as a naming and documentation boundary and not a tenant boundary at all.
  6. Should shc be enforced, or just conventional? Nothing stops the next shc install from landing a business app in shc. Making it mean something durable needs a gate in the master_reserved.go shape. Worth writing, or accept the convention?
  7. bitspur’s license-broker, is a vendor-facing licensing outage in scope at all? It serves license.selfhostedcloud.org, the address baked into every shipped binary. The ruling covered data, not availability. If bitspur is in scope, this stack needs its own window and its own plan; if it is not, say so and the shc tenant on bitspur is a later, separate exercise.
  8. Which estate first? Recommended: promanager only, Set A first, verified end-to-end (including a real browser login against the new shc realm) before Set B is touched, and bitspur not at all until promanager has been stable for a full renewal cycle.