license-broker folds into the portal deployment: 2026-08-20
Owner, 2026-08-20: “the license broker should actually be part of our portal deployment”.
This is the continuation of the 2026-08-18 architecture ruling already
recorded verbatim at the top of deploy/license-broker.shc.yaml:
“[shcd] is supposed to handle the cluster side of license… the license management itself, it’s keygen and any custom business logic, custom APIs… is supposed to be on the portal frappe.”
That file deferred one thing explicitly: “what can never move to Frappe is the signing seed and the shclic mint boundary the estates trust; where that lands is decided in the migration’s own lane, not silently here.” This document is that lane’s decision.
Verdict: the fold is correct, its tenant/database/ingress answers are all
settled, and it is blocked on exactly one thing that is not mine to do: the
marketplace bench’s own corp → shc tenant move, ruled on 2026-08-16 and
still not executed. The design is below; the question is in §8. Nothing on the
estate was mutated by this lane.
1. What “the portal deployment” is, concretely
Section titled “1. What “the portal deployment” is, concretely”There is no stack named portal on the estate, in either tenant. Measured on
bitspur-new (2.29.3.100), 2026-08-20:
$ shc ls -t corp | grep -iE 'market|portal'marketplace corp prod /var/lib/shc/_w34/marketplace/marketplace running
$ shc inspect marketplace -t corp (stack_record.json)"tenant": "corp", "stack_name": "marketplace", "environment": "prod","hosts": ["marketplace.selfhostedcloud.org", "api.marketplace.selfhostedcloud.org", "my.selfhostedcloud.org"],"host_specs": [ marketplace:3000 , bench-web:8000 , portal:3000 ],"access": "open", "exposure": "internet"The portal is the marketplace stack. Owner ruling 2026-08-16 merged them
onto one Frappe bench (one site, one database, two bench apps), and the
2026-08-17 ruling (“why the hell is this using frappe for the ui”) moved
my.<zone> off the bench onto its own One runtime inside the same stack. The
stack keeps the name marketplace deliberately (deploy/marketplace.shc.yaml
explains why renaming it installs a second stack rather than renaming the
live one).
So the candidates and their disposition, stated rather than picked silently:
| candidate | what it actually is | is it “the portal deployment”? |
|---|---|---|
marketplace stack, corp/prod | 9 services: bench-web/worker/scheduler/init/configure, mariadb, valkey, marketplace SSR, portal SSR. Serves all three selfhostedcloud.org product hosts. | Yes. This is the deployment. |
frappe/apps/portal | a bench app (code + schema) installed on that stack’s single site | a component of it, not a deployment |
apps/portal | the One/Tamagui runtime image behind my.<zone> | a service of it, not a deployment |
shc portal (CLI) | the estate-side verb that registers a cluster with the portal | a consumer, not the thing |
deploy/shc/portal, deploy/portal.shc.yaml | deleted 2026-08-16; merged_bench_test.go holds their tombstones | does not exist |
2. What license-broker is today
Section titled “2. What license-broker is today”Measured, same estate, same day:
$ shc ls -t shcSTACK TENANT ENV APP STATUSkeygen shc prod …/_platform/keygen/keygen runningkeygen-db shc prod …/_platform/keygen-db/keygen-db runninglicense-broker shc prod …/_platform/license-broker/… running- Its own stack, tenant
shc, envprod, app packagelicense-broker/app(deliberately outsideapps/, vendor infra, published only to the SHC-INFRA index). - One service, one image:
registry.gitlab.com/…/license-broker:90c8d648@sha256:ffa1334c…, 384M/0.75 CPU,expose: 8080. - No volumes, no
backup.yaml, no database. Stateless by construction: every/activatere-verifies from scratch and the rights ledger lives in Keygen. This is the single most important fact for §4. - One ingress host:
license.selfhostedcloud.org→license-broker:8080, path/,access: open(ungated; the SSO forward-auth gate would 401 every machine activation).$ shc ingress ls | grep licenseingress-shc_prod_license_broker.yaml shc_prod_license_brokerlicense.selfhostedcloud.org http://shc_prod_license_broker-license-broker-1:8080 - One integration:
keygenplug → provider stackkeygen, same tenant. The container is attached toshc_prod_keygen_publicand dialsLB_KEYGEN_URL=http://keygen-web:3000withLB_KEYGEN_HOST=prod.keygen-web.keygen. - Live and armed, proven from outside the process:
$ curl -s -o /dev/null -w '%{http_code}\n' --resolve license.selfhostedcloud.org:443:127.0.0.1 \-k https://license.selfhostedcloud.org/healthz200$ curl -s -o /dev/null -w '%{http_code}\n' … -X POST https://license.selfhostedcloud.org/sync401 # 404 would mean the vendor routes are unarmed
- All four product hosts already resolve to the new cluster:
license.,marketplace.,api.marketplace.andmy.all answer2.29.3.100. This is the live vendor estate, not a staging copy.
3. The three answers
Section titled “3. The three answers”3.1 Tenant: shc, and the fold does NOT move the broker
Section titled “3.1 Tenant: shc, and the fold does NOT move the broker”The merged deployment lives in tenant shc.
This is not a new ruling. docs/decisions/2026-08-16-marketplace-belongs-in-the-shc-tenant.md
already decided it; owner: “SHC’s own products leave the corp tenant”, and
the verdict there is “yes; marketplace belongs in the shc tenant, on the
class criterion, and it is by a wide margin the cheapest of the three tenant
moves.” Both packages tag themselves shc-infra; deploy/shc/marketplace/app.yaml
names license-broker/app as “the nearest sibling in shape”.
So the fold crosses a tenant boundary in one direction only, and it is not the broker’s:
license-brokeris already inshc(moved 2026-08-19 as the closure{license-broker, keygen, keygen-db}). The fold moves it nowhere.marketplaceis incorpand has to move toshcfirst. That move was ruled 2026-08-16 and has not happened.
There is no variant in which the merged stack sits in corp. The broker
reaches keygen by bare service name on keygen’s provider overlay, and ce
resolves an ordinary provider reference same-tenant only; the one
cross-tenant door (ce/modules/app/integration_magic.go) is a closed
allowlist holding a single row, KEYCLOAK, routed to master:
“a closed allowlist of system-namespace, critical-dependency providers… Every OTHER integration stays confined to the consumer’s own tenant.”
Keygen publishes no routed host at all (its stack record carries no
hosts key), so there is no public fallback either. A broker in corp with
keygen in shc mints nothing.
Putting keygen on the magic allowlist is not an escape: magic providers
resolve to (master, default), and master is builtin-only
(traefik/keycloak/openobserve/postgres). The customer rights ledger does not
belong in the system tenant.
3.2 Database: there is none to argue about
Section titled “3.2 Database: there is none to argue about”license-broker has no data store. No volumes in its compose, no
backup.yaml, and its app package says why: “Stateless by design (every
/activate re-verifies from scratch; purchases live in Keygen / the grants
var); no volumes, no backup.yaml, and replicas scale freely.”
So the owner’s hard rule (never share a database across tenants) is not engaged by the broker in any variant of this fold. Concretely:
- The broker gains no database from the fold. It does not get a table in the marketplace bench’s MariaDB. Folding it in means adding a container and a host to a compose project, not a schema to a site.
- The rights ledger stays where it is:
keygen-db, its own stack, its own tenant-local volume, inshc. Nothing about the fold touches it, and nothing about the fold gives the portal bench a connection to it. - The one database that moves is the marketplace bench’s own MariaDB, and
it moves whole, with its stack, from
corptoshc. That is relocation, not sharing; it is never readable from two tenants at once. Tenant isolation forbids the second, not the first.
That relocation is nevertheless the expensive part, because of what that
database holds. From deploy/shc/marketplace/backup.yaml, verbatim:
the database this stack now carries holds Cluster, Registration Code, Support Grant, Install Request, Install Spending Policy, and… Portal Cloud Credential, Cluster Secret, Terraform Run and Terraform State. None of that is derived from anything.
sites/additionally holds the site’s encryption_key, which is the ONLY thing that can decrypt the__Authrows those Password fields live in; a database restored without the matching sites volume is ciphertext.
The sites + mariadb pair is atomic or it is nothing. Any carry of this
stack takes both, together, or produces a site that authenticates nobody and a
provisioning ledger nobody can read.
3.3 Ingress: the broker keeps its own hostname. This is not negotiable.
Section titled “3.3 Ingress: the broker keeps its own hostname. This is not negotiable.”license.selfhostedcloud.org stays a host, bound at path /, on the
merged stack. It does not become a path on my.<zone> and it does not go
internal-only.
modules/license/broker.go:
const DefaultBrokerURL = "https://license.selfhostedcloud.org"“THIS VALUE IS SETTLED (owner ruling 2026-07-31, v0.0.12)… 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.”
There is no config key and no flag that changes where an estate renews
(SHC_LICENSE_BROKER_URL is the dev-loop door only). broker_url_test.go
already pins the literal; this lane adds
tests/unit/catalog/broker_deployfile_tenant_test.go, which pins the other
half: that the deployfile’s prod render equals that constant’s host, and
that the broker is never bound at a path.
x-shc-path (secondary routes on one host) is the right tool for a surface
that is genuinely a sub-path of another product. It is the wrong tool here:
/activate, /register, /record, /sync and /mint are all root-relative
on DefaultBrokerURL, and every binary in the field concatenates them onto it.
The merged deployment therefore serves four hosts from four services:
marketplace.<zone> marketplace:3000 SSR storefront, anonymousapi.marketplace.<zone> bench-web:8000 the Frappe bench, under its site namemy.<zone> portal:3000 the One runtimelicense.<zone> license-broker:8080 the activation API <- newaccess is a stack-level property and both stacks are already open, so the
broker’s ungated posture survives the merge unchanged. exposure: internet
(prod LE chain via acme-prod-dns-hetzner) is what the marketplace stack
already has and what the broker needs.
The surface order matters: the first surface names the GitLab environment
URL, so marketplace.{host} stays first and the broker is appended last.
4. Integrations: who consumes the broker, and what the fold does to each
Section titled “4. Integrations: who consumes the broker, and what the fold does to each”| consumer | how it reaches the broker | effect of the fold |
|---|---|---|
every SHC estate in the field: POST /activate, the periodic soft re-verify, shc license refresh | DefaultBrokerURL, compiled in | none; same host, same path, same TLS chain |
CI / lab estates: shc license register <code>, the shc_license terraform resource | same host, POST /register | none |
ERPNext: erpnext/sync_paid_invoices.py, invoice-paid → POST /record | broker_url in its own config, over the public host | none; and note ERPNext stays in corp; it calls the broker over the internet, not over an overlay, so no tenant edge exists to break |
vendor ops: POST /mint, POST /sync | same host + LB_VENDOR_TOKEN | none |
| keygen: the mint backend | keygen.plug.yaml → shc_prod_keygen_public, http://keygen-web:3000 | the one edge at risk. Same-tenant-only; survives iff the merged stack is in shc (§3.1) and the edge is re-established on it (§6.3) |
| the marketplace/portal bench | does not call the broker today; frappe/apps/portal names it only in comments (dispatch.py:177, install_request.py:146,880), never in a request | unchanged; the 2026-08-18 ruling’s eventual “business logic on the portal frappe” is a later lane |
Nothing else breaks. The two things that would break (the compiled-in host and the keygen overlay) are the two things §3.3 and §3.1 refuse to move.
5. Keygen stays separate, yes, unchanged
Section titled “5. Keygen stays separate, yes, unchanged”Owner’s standing architecture (SHC canon: “builtin = traefik/keycloak/ openobserve/postgres ONLY; shcd owns branding + license cluster-side; frappe owns marketplace/portal/license business logic; keygen separate”), and the 2026-08-18 ruling restates it: “it’s keygen and any custom business logic… with Keygen staying its own service.”
So after the fold, tenant shc holds two deployments where it holds three
today:
before after keygen keygen (unchanged, own stack) keygen-db keygen-db (unchanged, the ledger) license-broker marketplace (storefront + bench + portal + broker) marketplace (in corp)The signing seed does not move to Frappe. It stays what it is: a required
(non-autogen) vault ref resolved at install into SHC_LICENSE_SIGNING_KEY on
the broker container, failing closed with X404905SECREQ when absent. The
shclic mint boundary stays in the Go service. That is the part of the
2026-08-18 ruling this lane rules on, and the ruling is: the boundary does
not move; only its deployment does.
6. The migration path for the existing deployment
Section titled “6. The migration path for the existing deployment”Ordered, and each step is a decision someone can refuse.
6.1 Precondition: confirm which estate CI reaches
Section titled “6.1 Precondition: confirm which estate CI reaches”SHC_HOST is a protected project CI variable. It read 37.27.215.210 on
2026-08-16 (the legacy cluster). The estate flipped to 2.29.3.100 on
2026-08-19 and all four product hostnames now resolve there. The legacy
host is still up and answering ICMP. Nobody plays any gate until SHC_HOST is
read and confirmed to name the cluster that is actually serving. This is not
part of the fold; it is a precondition of any deploy from this repo.
6.2 The marketplace tenant move: the gating step, not mine
Section titled “6.2 The marketplace tenant move: the gating step, not mine”marketplace must be at (shc, marketplace, prod) before anything is folded
into it. Two mechanisms exist and they are not equivalent:
shc move --target-tenant shc(clone.Move): a real relocation, carries the mounts. This is the path the licence closure took on 2026-08-19, and it came back with three open ce bugs measured on this estate: a quiesce hook unexecable mid-move (X500467BKPHKF), cross-tenant recovery discarding the scaffold error (X404401STKNOF; ce!33 fixed preflight only), and the move leaving targets stopped and routeless. On a stateless 256M broker that is an annoyance. On the stack holding customer cloud credentials, the cluster registry and terraform state it is an outage plus a manual repair.- backup → install-in-
shc→ recover → retirecorp; the deployfile path cannot relocate (§5 of the 2026-08-16 decision: “a tenant change is a fresh install, not a relocation”), so this is the explicit-carry alternative. It produces a provable archive of thesites+mariadbpair before anything is destroyed, which the live saga does not. It costs a downtime window, because two stacks cannot both holdmarketplace.selfhostedcloud.org(see 6.5), and the archive is customer cloud credentials; theportal-backup-guard.shcustody rules apply to it in full.
Do not flip deploy/marketplace.shc.yaml to tenant: shc before the move.
The CI existence check matches the tenant, so a flip ahead of the move takes
the install branch and stands up a second, empty bench beside the live one,
both claiming three public hostnames. That flip is step 3 of the 2026-08-16
decision’s own order of operations and it is the last step, not the first.
6.3 Re-establishing the keygen edge: one manual command, and it has to be
Section titled “6.3 Re-establishing the keygen edge: one manual command, and it has to be”The deployfile grammar has no integrate: key (ce’s deployfileRaw is
stack/app/public/domain/vars/surfaces/environments), and the CI deploy path
emits no -i; shc-base.yml builds exactly
shc install|update $TENANT_FLAG … $HOST_FLAGS $PUBLIC_FLAG $VAR_FLAGS.
The socket-less fallback is closed too, and this is measured rather than assumed:
$ shc deploy -f probe2.shc.yaml -e prod --dry-runshc: [X400408DPFREQ] deployfile …: vars.keygen.token is missing or unusable:'keygen.token=ref+vault://keygen_admin_token' carries characters outside[A-Za-z0-9._:@/=-]; the same charset the CI generator enforcesref+vault:// cannot be spelled in a deployfile var, because + is outside
the generator’s safe() charset. So the token can only ever arrive as a
default in the app package’s own vars.yaml (which is correct and is where
signingKey already lives), and apiUrl/apiHost/accountId can only
arrive from the socket.
Therefore the edge is created once, by hand, and then never again:
shc update marketplace -t shc -e prod -i keygen=keygenshc update documents this as supported in place: “Integrations are
persistent deployment state like routes, ports and --var overrides: -i
oidc=keycloak adds or repoints ONE edge and leaves every other integration on
the deployment wired.” There is no shc integration add; shc integration
is ls/plugs/sockets only, so shc update -i is the whole mechanism. It
is one command, it is logged in the ops intervention log, and every subsequent
CI deploy replays it from persisted state.
This is a genuine product gap and belongs on the zero-manual-intervention backlog: a deployfile cannot express an integration, so any stack with a plug needs one out-of-band command before CI can own it.
6.4 The package change
Section titled “6.4 The package change”deploy/shc/marketplace/compose.yamlgains thelicense-brokerservice, lifted verbatim fromlicense-broker/app/compose.yaml, including its healthcheck, its resource limits and its{% if integrations.keygen … %}block.deploy/shc/marketplace/gainskeygen.plug.yaml(copied fromlicense-broker/app/), so the plug’srequired:guard still fails the install fast rather than letting the container crash-loop.deploy/shc/marketplace/vars.yamlgains the broker’s var tree:signingKey(the required vault ref),callbackTimeout,vendorToken(empty by default; arming it is a per-install decision),keygen.*andimages.licenseBroker.deploy/marketplace.shc.yamlgains the fourth surfacelicense-broker:8080@license.{host}andimages.licenseBroker.deploy/license-broker.shc.yamlis deleted in the same commit;TestExactlyOneDeployfileBindsTheBrokerfails otherwise, and two deployments on one hostname is not refused anywhere.license-broker/app/stays (do not delete it): it is still published to the SHC-INFRA index that terraform’sshc_deploymentreads, andlicense-broker/README.md’s terraform wiring depends on it.
6.5 The cutover, and why it needs a window
Section titled “6.5 The cutover, and why it needs a window”Two deployments claiming one hostname is not an error anywhere. ce’s error
corpus has no cross-tenant hostname claim (the only “already claimed” host
error is X400988PRTDUP, about shared-vip ports), and the ingress is
written one file per deployment:
ingress-shc_prod_license_broker.yaml license.selfhostedcloud.orgingress-corp_prod_marketplace.yaml marketplace./api.marketplace./my.A second file with the same Host rule is a tie traefik breaks by router name,
not something an operator is told about. So the old license-broker stack is
uninstalled in the same window the merged stack takes over the host, and
the activation baseline (healthz + a fixed-nonce /activate decline, which
is byte-deterministic) is captured before and after.
6.6 What the fold costs, stated so it is a choice
Section titled “6.6 What the fold costs, stated so it is a choice”- The licence mint path inherits the storefront’s release cadence. Today the broker is a stateless container nobody restarts. Folded in, every marketplace deploy re-renders and recreates it, and every bench migration window is a window in the same compose project as the mint path.
- Multi-vantage validation gets harder.
license-broker/README.mdnames the compensating control for dropping the TLS leg: “run several broker replicas on different networks/providers behind the activation host.” Replicas of a service inside a stack that also owns a singleton MariaDB are pinned to that stack’s placement. - The image pin weakens. The live broker runs a digest-pinned image
(
:90c8d648@sha256:ffa1334c…) andlicense-broker/app/vars.yamlargues at length why a signing service must not ride a moving tag. Both deployfiles override with${CI_REGISTRY_IMAGE}/…:${CI_COMMIT_SHORT_SHA}, immutable by convention, not by digest. That trade is already made by the deployfile; the fold inherits it rather than introducing it.
None of these is disqualifying. All three are the price of the direction the 2026-08-18 ruling set, and they should be paid knowingly.
7. What this MR does
Section titled “7. What this MR does”Landed (safe, reversible, and required by every variant of the fold):
-
deploy/license-broker.shc.yamlgainstenant: shc. This closes a live one-click hazard that predates the fold: the file landed 2026-08-18, the closure move toshchappened 2026-08-19, and the file’s own header still claimed “after the move the keys agree”. They did not; with notenant:key the deploy targets$SHC_TENANT(measuredcorp), so playinggate_prod:license-brokerwould have installed a second broker in the tenant the live one had just left, both claiming the activation host. With the key, the CI existence check matchesshc/license-broker/prodand the same click becomes an ordinary update of the live stack.Proven end-to-end against the pinned generator (
cicd@0ac192a4):$ CI_REGISTRY_IMAGE=… CI_COMMIT_SHORT_SHA=deadbeef sh generate.shgenerate.sh: 2 deployfile(s): deploy/license-broker.shc.yaml deploy/marketplace.shc.yaml...deploy_prod:license-broker:SHC_STACK: license-brokerSHC_STACK_TENANT: shcSHC_HOSTS: "license-broker:[email protected]" -
tests/unit/catalog/broker_deployfile_tenant_test.go: three guards that make the half-fold un-landable: exactly one deployfile may bind the broker service; the deployfile that does must pintenant:to keygen’s tenant; and its prod render must equallicense.DefaultBrokerURL’s host, at path/. The middle one fails onmainas it stands and passes after (1). -
This document.
Deliberately not landed:
- The merged compose/vars/surface (§6.4). Landing it before the marketplace
tenant move would arm a worse hazard than the one being fixed: one click on
gate_prod:marketplacewould add a broker container to the corp stack, where it would claimlicense.selfhostedcloud.orgagainst the live broker and crash-loop, becausemain.goexits 1 with no mint backend and the deployfile path cannot give it one. tenant: shcondeploy/marketplace.shc.yaml. That is the premature flip the 2026-08-16 decision’s §5 and §7 both warn about: the existence check would route the run to install, standing up a second empty bench beside the live one.- Any estate mutation. Nothing was installed, updated, moved, restarted or
uninstalled by this lane; every command run against 2.29.3.100 was a read
(
ls,inspect,ingress ls,--help,deploy --dry-runon a throwaway file in/var/tmp/shct/broker/) or acurlprobe.
8. ★ The one thing that needs ruling
Section titled “8. ★ The one thing that needs ruling”Does the marketplace/portal bench move corp → shc now, and by which
mechanism: the live shc move saga, or a backup-carry cutover with a window?
Everything else in this design is settled. That move is:
- already ruled in principle (2026-08-16, “SHC’s own products leave the corp tenant”), never executed;
- the only reason the fold cannot be done tonight, because the merged stack
must share keygen’s tenant and keygen’s tenant is
shc; - an operation on a live, customer-facing stack whose database holds Portal
Cloud Credentials, Cluster Secrets and terraform state, whose
sitesvolume holds the only key that decrypts them, and whose move path has three open ce bugs measured on this estate one day ago, one of which leaves the moved stack stopped and routeless.
The licence ledger on this estate has been destroyed once already by a terraform path. That is the standard this move has to clear, and clearing it is an owner decision with a window, not a lane decision at 06:00.
Once it is ruled, §6.3–6.5 are a single afternoon: copy four files, add one
surface, delete one deployfile, run one shc update -i, capture the activation
baseline either side.
9. Defects and gaps this lane found
Section titled “9. Defects and gaps this lane found”deploy/license-broker.shc.yamltargeted the wrong tenant. Fixed here. Severity: one click from two brokers on one hostname, silently.- The two deployfile renderers disagree about
tenant:. The cicd generator reads it (0ac192a4, “TENANT AXIS”); ce’sParseDeployfiledecodes withKnownFields(true)and has noTenantfield, so:The$ shc deploy -f probe.shc.yaml -e prod --dry-runshc: [X400406DPFPRS] … line 3: field tenant not found in type commands.deployfileRawsafeValuecomment in that same file says a value one renderer accepts and the other refuses “would make a deployfile non-portable between the two renderers, the one thing the primitive exists to prevent.” Owed: aTenant string \yaml:“tenant”`field plus its-tplumbing ince/modules/app/commands/deployfile.go`. - A deployfile cannot express an integration. No
integrate:key, no-iinshc-base.yml. Every stack with a plug needs one out-of-bandshc update -ibefore CI can own it. Zero-manual-intervention backlog. ref+vault://cannot ride a deployfile var (+is outside the generator’s charset,X400408DPFREQ). Not a bug; the right answer is that secrets live in the package’svars.yaml, but it should be stated in the deployfile docs rather than discovered.tests/unit/catalog/vendor_infra_placement_test.go’s rationale is stale. Its header still reads “Measured live on the bitspur estate, 2026-08-16.shc ls --all-tenantsputlicense-brokerat tenant=corp/env=prod” and “on the vendor’s own estate, where it MUST share a tenant with customer-facing apps”. Since 2026-08-19 the broker shares its tenant with nothing but keygen and keygen-db. The assertions are still correct (launcher_placed: falseis still the right posture); only the argument is out of date. Left alone here to keep this MR’s diff about one thing.SHC_HOSThas not been confirmed against the cluster flip (§6.1).
Appendix: every command this lane ran against the live estate
Section titled “Appendix: every command this lane ran against the live estate”Zero mutations. Recorded verbatim because the rule is that manual estate commands get logged whether or not they changed anything, and because a design argued from an estate is only as good as the reads behind it.
All against ssh -i ~/.ssh/hel1_new [email protected] (bitspur-new, owner
LIVE), 2026-08-20.
| command | why |
|---|---|
shc version | establish the daemon build (0.0.60) before trusting any other read |
shc tenant ls | the tenant census: shc 3 stacks, corp 79, master 4 |
shc ls -t shc / shc ls -t master / shc ls -t corp | grep -iE 'market|portal|frappe|erp|license|keygen' | which tenant holds the broker, keygen and the portal today |
shc inspect license-broker -t shc | the broker’s rendered compose, plug, hosts, integrations and networks, §2 |
shc inspect keygen -t shc | awk '/stack_record/,0' | prove keygen has no routed host, so there is no public fallback |
shc inspect marketplace -t corp | the portal deployment’s services, vars, hosts, backup.yaml, §1, §3.2 |
shc ingress ls | the live routers, one file per deployment, the collision argument in §6.5 |
shc --help, shc deploy --help, shc update --help, shc integration --help | establish that -i is an install/update flag and that shc integration has no add, §6.3 |
shc deploy -f /var/tmp/shct/broker/probe.shc.yaml -e prod --dry-run | prove ce’s parser refuses tenant: (X400406DPFPRS). Throwaway file in this lane’s own scratch dir; --dry-run needs no daemon and changes nothing |
shc deploy -f /var/tmp/shct/broker/probe2.shc.yaml -e prod --dry-run | prove ref+vault:// cannot ride a deployfile var (X400408DPFREQ) |
curl … --resolve license.selfhostedcloud.org:443:127.0.0.1 -k https://…/healthz → 200 | the broker is serving |
curl … -X POST https://license.selfhostedcloud.org/sync → 401 | the vendor routes are armed on the running image (404 would mean unarmed) |
Off-estate, on the lane box: dig +short on the four product hostnames (all
2.29.3.100), ping -c1 37.27.215.210 (legacy cluster still up), and the
pinned cicd@0ac192a4 generator run over deploy/ in a scratch dir to prove
the emitted SHC_STACK_TENANT.