Licensing BNK with the F5 License Proxy (FLP)
Field specs live in Chapter 28 — Configuration reference. That chapter is generated from the
Workspacestruct and checked by a test, so it cannot drift. Tables here are for teaching and may be shortened over time; when they disagree with Chapter 28, Chapter 28 is right.
By default roksbnkctl licenses BIG-IP Next for Kubernetes (BNK) with a
subscription JWT — the subscription.jwt (or your production token) staged in the
orchestration COS bucket. In that mode the cluster’s controller reaches F5’s
licensing service directly. Nothing in this chapter changes that default.
Some environments prefer (or require) an F5 License Proxy (FLP): an in-cluster
service that brokers licensing on behalf of every BNK instance in the cluster,
so the workloads themselves never talk to F5 directly. roksbnkctl can deploy
the FLP and point BNK at it, as an opt-in capability — a new flp lifecycle
phase plus a one-line config switch. Both licensing modes are first-class; if you
don’t opt in, the JWT path is byte-for-byte unchanged.
FLP is optional. Everything here is gated behind
bnk.license_mode: f5licenseproxy. Leave it unset (the default) and BNK licenses with the subscription JWT exactly as before — noflpphase, no extra resources.
What the FLP is
The FLP is a Helm-installed workload (the f5-license-proxy chart: the proxy
itself plus a bundled Vault and PostgreSQL). It presents an in-cluster TLS
endpoint that the BNK Cluster-Wide Controller (CWC) calls for licensing; the
proxy forwards to F5’s licensing backend. Because the CWC must trust the proxy’s
TLS, the proxy’s root CA is delivered to the CWC and the BNK License
custom resource is set to operationMode: f5licenseproxy with the proxy’s
service URL.
roksbnkctl automates all of that: roksbnkctl flp up generates the proxy’s CA
and mTLS certs, creates its secrets, installs the chart (pulling from your
registry mirror or FAR), and records the CA + endpoint. A later bnk up reads
that handoff and wires the License CR — you never copy a certificate by hand.
The FLP’s charts and images are part of the standard BNK bill of materials, so
registry replicate already mirrors them into a
private registry — an air-gapped, FLP-licensed install pulls everything,
including the proxy, from a registry you control.
Three topologies
The proxy is a cluster-wide broker, and it is the only component that needs to reach F5. That gives you three ways to arrange it:
| Where the proxy runs | Use it when | |
|---|---|---|
| Flow A | the cluster roksbnkctl creates | the normal case |
| Flow B | a cluster you already own and register | you did not provision the cluster |
| Flow C | a different cluster — one proxy serving many | only one cluster may reach F5; the rest are air-gapped |
Flows A and B are the same shape: proxy and BNK in one cluster. Flow C splits them.
The flp phase
Like testing and gateway, the FLP is an
independent, opt-in phase with its own terraform state (state-flp/). The
composite roksbnkctl up never runs it; you run it explicitly, between the
cluster and BNK:
roksbnkctl flp up # install the proxy into an existing cluster
roksbnkctl flp down # remove it (leaves cluster / BNK / testing intact)
roksbnkctl flp output # print its terraform outputs (endpoint, namespace)
flp up refuses if the workspace has no cluster yet, and records
flp-outputs.json (the proxy’s root CA + service endpoint) on success. flp down is a no-op success when there is no FLP state, so it is safe in a
reverse-order teardown of every phase.
The proxy installs into the f5-license-proxy namespace by default; override
with bnk.flp.namespace (or ROKSBNKCTL_FLP_NAMESPACE).
Opting in
Set the license mode in the workspace config.yaml:
bnk:
manifest_version: 2.3.0-3.2598.3-0.0.170
license_mode: f5licenseproxy # connected (default) | disconnected | f5licenseproxy
flp:
namespace: f5-license-proxy # optional; this is the default
Or answer yes to License via an in-cluster F5 License Proxy (FLP)? in the
roksbnkctl init interview, or set it non-interactively:
export ROKSBNKCTL_LICENSE_MODE=f5licenseproxy
export ROKSBNKCTL_FLP_NAMESPACE=f5-license-proxy # optional
The subscription JWT is still required in FLP mode (the proxy presents it to
F5); it is resolved from COS exactly as in the JWT path — no change to
bnk.subscription_jwt_file or its credential.
Flow A — a cluster you are creating
The full sequence when roksbnkctl provisions the cluster:
# 1. Seed the workspace with FLP mode (interview, config.yaml, or env).
roksbnkctl -w prod init # answer "yes" to the FLP prompt
# 2. Create the cluster.
roksbnkctl -w prod cluster up
# 3. (Optional) mirror BNK — including the FLP — into your private registry.
# Skip this to pull from repo.f5.com directly.
roksbnkctl -w prod registry replicate --target generic
# 4. Install the F5 License Proxy.
roksbnkctl -w prod flp up
# 5. Install BNK — it licenses via the proxy automatically.
roksbnkctl -w prod bnk up
Step 5 reads flp-outputs.json and sets the License CR to
operationMode: f5licenseproxy, its teem*Url at the proxy service, and
delivers the proxy root CA to the CWC. bnk up errors clearly if the flp
phase has not been run.
Flow B — an existing cluster registered in the workspace
You do not have to let roksbnkctl build the cluster. If you already have a ROKS
cluster, register it into the workspace
and install the proxy onto it. Registration looks the cluster up in your IBM Cloud
account and writes the very same cluster-outputs.json that the cluster up path
produces — and that is the only thing the FLP and BNK phases consume. So from
step 3 on, the two flows are character-for-character identical:
# 1. Seed the workspace with FLP mode, and do NOT create a cluster.
roksbnkctl -w prod init # answer "no" to "create a cluster?", "yes" to FLP
# (equivalently, in config.yaml: cluster.create: false + bnk.license_mode: f5licenseproxy)
# 2. Register the cluster you already have.
roksbnkctl -w prod cluster register my-existing-roks
# 3. (Optional) mirror BNK — including the FLP — into your private registry.
roksbnkctl -w prod registry replicate --target generic
# 4. Install the F5 License Proxy into the registered cluster.
roksbnkctl -w prod flp up
# 5. Install BNK, licensed via the proxy.
roksbnkctl -w prod bnk up
roksbnkctl never takes ownership of a registered cluster. flp up adds only
the proxy workload (its namespace, secrets and Helm release); flp down removes
exactly that and nothing else. The cluster itself is never created, modified at the
infrastructure level, or destroyed — cluster down will not touch it.
FLP behind a private registry
The FLP’s chart and its four images are part of the standard BNK bill of
materials, so registry replicate mirrors them
along with everything else. Combining the two gives a genuinely disconnected,
FLP-licensed install: flp up and bnk up pull every chart and image from
your registry, and the CWC brokers licensing through the in-cluster proxy rather
than reaching F5 itself.
Nothing extra is required — point the workspace at the mirror and the FLP phase follows it automatically:
roksbnkctl -w prod registry target generic # your Harbor/Artifactory/ICR
roksbnkctl -w prod registry replicate # mirrors BNK + the FLP
roksbnkctl -w prod flp up # proxy, pulled from the mirror
roksbnkctl -w prod bnk up # BNK, pulled from the mirror
Flow C — a shared licensing cluster
Flows A and B both put the proxy and BNK in the same cluster. But the proxy is a cluster-wide licensing broker, and it is the only thing that needs to reach F5. So you can run it once, in a cluster that has egress, and have BNK installs in other clusters license through it — clusters that reach nothing but your mirror and the proxy.
┌──────────────── services cluster (has egress to F5) ─────────────┐
│ F5 License Proxy ──NodePort 30001──┐ │
└──────────────────────────────────────┼───────────────────────────┘
│ same VPC, or a transit gateway
┌──────────────────────────────────────┼── air-gapped cluster ─────┐
│ BNK + CWC ─────────────────────────┘ │
│ └── charts + images ── your private registry (Harbor/…) │
└──────────────────────────────────────────────────────────────────┘
Neither cluster reaches repo.f5.com, and only the services cluster reaches F5’s
licensing service.
1. The services cluster — expose the proxy
roksbnkctl -w services cluster up # (or `cluster register` an existing one)
# point the workspace at your private registry, then mirror FAR into it
roksbnkctl -w services registry target generic
roksbnkctl -w services registry target generic_host harbor.example.com
roksbnkctl -w services registry target generic_repo_prefix bnk-mirror
roksbnkctl -w services registry target generic_username admin
printf '%s' "$HARBOR_PASSWORD" | \
roksbnkctl -w services registry target generic_password --password-stdin
roksbnkctl -w services registry replicate # BNK *and* the FLP chart — both are in the BOM
roksbnkctl -w services flp up \
--add-node-port-access \
--node-port-source-cidr 10.242.0.0/18,10.242.64.0/18,10.242.128.0/18
Set the registry target before replicating: with none set it defaults to icr, and
you would mirror into IBM Container Registry rather than your own. The password is piped
on stdin so it never lands in argv or your shell history. See
Registry targets for the ICR and Artifactory variants.
The proxy itself is installed from that registry — charts/f5-license-proxy is part
of the mirror BOM, so even the licensing component does not come from repo.f5.com.
The CIDR flag is a list, and it must name every zone. A multi-zone VPC carries one address prefix per zone:
$ ibmcloud is vpc-address-prefixes <vpc> --output json | jq -r '.[] | "\(.zone.name) \(.cidr)"'
eu-gb-1 10.242.0.0/18
eu-gb-2 10.242.64.0/18
eu-gb-3 10.242.128.0/18
List only the first and the proxy will appear to work — a pod you exec into for a test
may well be scheduled in that zone and get an HTTP 200 — while the consuming cluster’s
CWC, scheduled in one of the other two, is dropped at the security group and reports
connect: connection timed out. The symptom is a proxy that answers some pods and
silently times out for others. Pass every prefix, or a supernet covering them.
No BNK is installed here — this cluster exists to run the proxy.
--add-node-port-access does three things you cannot do by hand afterwards:
- Makes every worker answer. The chart’s Service is already
type: NodePort(30001), but it hardcodesexternalTrafficPolicy: Localand runs one replica — so only the node currently hosting the pod answers, and that node changes when the pod reschedules. This flips it toCluster, so any worker IP is a valid endpoint. - Puts the worker IPs in the proxy’s certificate. A remote CWC dials
https://<node-ip>:30001— a literal address, which DNS SANs do not cover. Without IP SANs the TLS handshake fails withbad certificate. - Opens the port. ROKS workers sit in a
kube-<cluster-id>security group that does not admit another cluster.--node-port-source-cidropens only 30001, and only to the CIDRs you name — one security-group rule per prefix. Omit it if a path already exists.
It prints the address to hand over, and records it in flp-outputs.json:
→ FLP reachable from other clusters at https://10.242.0.9:30001
2. The consuming cluster — license against it
Read the endpoint and CA out of the owning workspace:
roksbnkctl -w services flp output # → external_endpoint, root_ca_b64
and point the other workspace at them. It never runs flp up — it does not own a
proxy:
# consuming workspace's config.yaml
bnk:
license_mode: f5licenseproxy
flp:
external:
url: https://10.242.0.9:30001 # from `flp output` → external_endpoint
root_ca_b64: LS0tLS1CRUdJTi… # from `flp output` → root_ca_b64
Point that workspace at the same private registry, and install. bnk up wires the
License CR at the remote proxy and delivers its CA to the CWC, exactly as it would for a
local one:
roksbnkctl -w app cluster register my-app-cluster # or `cluster up` to build one
# the SAME registry as the services workspace
roksbnkctl -w app registry target generic
roksbnkctl -w app registry target generic_host harbor.example.com
roksbnkctl -w app registry target generic_repo_prefix bnk-mirror
roksbnkctl -w app registry target generic_username admin
printf '%s' "$HARBOR_PASSWORD" | \
roksbnkctl -w app registry target generic_password --password-stdin
roksbnkctl -w app registry replicate # copies nothing — the artifacts are already there
roksbnkctl -w app bnk up # licenses via the proxy in the OTHER cluster
registry replicate in the second workspace has nothing left to copy. Run it anyway:
its other job is to write registry-mirror.json, and that record is what redirects the
install off repo.f5.com onto your registry. Without it, bnk up would go to FAR.
(See One mirror, many clusters.)
Why this cluster is genuinely disconnected
Three things have to be true, and bnk up arranges all three — there is nothing to wire
by hand:
- Charts and images come from your registry. Chart pulls log in with the credential
above; the pods get a
mirror-secretdockerconfig built from it, created in every namespace that pulls (cert-manager, the FLO/BNK namespaces,kube-systemfor the node-labeler) and referenced from the CNEInstance. Your registry stays private — it needs no anonymous or public project. - The manifest is already in the cluster. The BNK manifest is mirrored too and
pre-applied as a
CNEManifestCR, so the lifecycle operator resolves it locally instead of fetching it from F5. - Licensing goes to the proxy next door, not to F5.
The result: this cluster talks to your registry and to https://<node-ip>:30001. Nothing
else.
Flow C in CI — the runner container, no host install
Everything above is a roksbnkctl you installed. The same topology runs as a CI
pipeline with nothing installed at all: every step is the
tools-runner container, and the whole workspace is
described by environment variables — the natural shape of CI, where the registry
credential and the proxy handoff are already secrets and job outputs.
Two jobs. The first owns the proxy and emits its address and CA; the second installs BNK into a cluster that reaches nothing but the registry and that proxy.
# .github/workflows/bnk-disconnected.yml
env:
RUNNER: ghcr.io/jgruberf5/roksbnkctl-tools-runner:v1.19.0
jobs:
licensing-cluster:
runs-on: ubuntu-latest
container: ghcr.io/jgruberf5/roksbnkctl-tools-runner:v1.19.0
outputs:
flp_url: ${{ steps.flp.outputs.url }} # ← the handoff
flp_ca: ${{ steps.flp.outputs.ca }}
env:
IBMCLOUD_API_KEY: ${{ secrets.IBMCLOUD_API_KEY }}
ROKSBNKCTL_REGION: eu-gb
ROKSBNKCTL_RESOURCE_GROUP: default
ROKSBNKCTL_PREFIX: ci-svc
ROKSBNKCTL_CLUSTER_NAME: ${{ vars.SERVICES_CLUSTER }}
ROKSBNKCTL_CLUSTER_CREATE: "false" # adopt it; do not build it
ROKSBNKCTL_REGISTRY_TARGET: generic
ROKSBNKCTL_GENERIC_HOST: ${{ vars.REGISTRY_HOST }}
ROKSBNKCTL_GENERIC_REPO_PREFIX: bnk-mirror
ROKSBNKCTL_GENERIC_USERNAME: ${{ vars.REGISTRY_USER }}
ROKSBNKCTL_GENERIC_PASSWORD: ${{ secrets.REGISTRY_PASSWORD }}
steps:
- run: roksbnkctl -w ci-svc init --non-interactive --override-from-env
- run: roksbnkctl -w ci-svc cluster register "$ROKSBNKCTL_CLUSTER_NAME"
- run: roksbnkctl -w ci-svc registry replicate --target generic
- run: roksbnkctl -w ci-svc registry verify
- name: Deploy the proxy, reachable from the other cluster
run: |
roksbnkctl -w ci-svc flp up --auto \
--add-node-port-access \
--node-port-source-cidr "${{ vars.APP_CLUSTER_CIDRS }}"
- id: flp
run: |
echo "url=$(roksbnkctl -w ci-svc flp output flp_external_endpoint)" >> "$GITHUB_OUTPUT"
echo "ca=$(roksbnkctl -w ci-svc flp output flp_root_ca)" >> "$GITHUB_OUTPUT"
application-cluster:
needs: licensing-cluster
runs-on: ubuntu-latest
container: ghcr.io/jgruberf5/roksbnkctl-tools-runner:v1.19.0
env:
IBMCLOUD_API_KEY: ${{ secrets.IBMCLOUD_API_KEY }}
ROKSBNKCTL_REGION: eu-gb
ROKSBNKCTL_RESOURCE_GROUP: default
ROKSBNKCTL_PREFIX: ci-app
ROKSBNKCTL_CLUSTER_NAME: ${{ vars.APP_CLUSTER }}
ROKSBNKCTL_CLUSTER_CREATE: "false"
ROKSBNKCTL_REGISTRY_TARGET: generic
ROKSBNKCTL_GENERIC_HOST: ${{ vars.REGISTRY_HOST }}
ROKSBNKCTL_GENERIC_REPO_PREFIX: bnk-mirror
ROKSBNKCTL_GENERIC_USERNAME: ${{ vars.REGISTRY_USER }}
ROKSBNKCTL_GENERIC_PASSWORD: ${{ secrets.REGISTRY_PASSWORD }}
# ── license through the proxy in the OTHER cluster ──
ROKSBNKCTL_LICENSE_MODE: f5licenseproxy
ROKSBNKCTL_FLP_EXTERNAL_URL: ${{ needs.licensing-cluster.outputs.flp_url }}
ROKSBNKCTL_FLP_ROOT_CA_B64: ${{ needs.licensing-cluster.outputs.flp_ca }}
steps:
- run: roksbnkctl -w ci-app init --non-interactive --override-from-env
- run: roksbnkctl -w ci-app cluster register "$ROKSBNKCTL_CLUSTER_NAME"
- run: roksbnkctl -w ci-app registry replicate --target generic # records the mirror
- run: roksbnkctl -w ci-app bnk up --auto
- name: Gate the pipeline on the license
run: roksbnkctl -w ci-app k get license -n f5-utils
The handoff is two environment variables. ROKSBNKCTL_FLP_EXTERNAL_URL and
ROKSBNKCTL_FLP_ROOT_CA_B64 are exactly what flp output prints, so the proxy’s
address and CA travel between jobs as ordinary job outputs. Nothing templates a
config.yaml; init --override-from-env builds the whole workspace from the
environment. (flp_root_ca is already base64, and the variable takes it verbatim —
re-encoding it hands the CWC a corrupt CA.)
Neither job installs anything. No roksbnkctl, no terraform, no helm, no
kubectl, no ibmcloud — the runner image carries them, and roksbnkctl runs the
Kubernetes verbs in-process. That includes the FLP chart’s post-render fix-ups, which
roksbnkctl performs itself (roksbnkctl flp postrender) rather than shelling out to an
interpreter the image does not have.
State lives in the workspace directory, which in a container is ephemeral. For a
pipeline that will run again — to upgrade, or to tear down — put the terraform state in
COS/S3 (roksbnkctl state migrate); see
Remote state and
Ephemeral runners need remote state.
The demo below mounts a volume instead, which is the same idea with a shorter lifetime.
What the last step proves. k get license prints the CR the CWC wrote:
NAME STATE MODE ENTITLEMENT ENVIRONMENT EXPIRY
bnk-license Active f5licenseproxy eval test 2026-08-13T16:11:06Z
Active + f5licenseproxy, in a cluster with no proxy of its own and no route to
repo.f5.com. Fail the job on anything else and the pipeline gates on the license.
What to watch out for
- The two clusters must be able to reach each other — same VPC (simplest: give the
second cluster
resources.cluster_vpc.create: false+existing: <vpc-id>), or a transit gateway between their VPCs. - Worker IPs change when a worker is replaced. The certificate covers the IPs that
existed at
flp uptime, so replacing a node in the services cluster means re-runningflp up(which re-issues the cert) and updating the consuming workspace if you pinned the URL of the node that went away.flp outputlists every worker URL — all are cert SANs — so you can point at another one. A stable VIP would avoid this entirely; NodePort is the trade-off you accept for not needing a load balancer. - The consuming workspace needs no
flpphase at all — nostate-flp/, nothing to tear down.bnk downthere leaves the proxy untouched, serving its other clusters.
Running the FLP as a VSI (mode: vsi)
The flows above run the FLP as an in-cluster Helm deployment. It can instead run as a
standalone Virtual Server Instance — a VM, no Kubernetes — which is the right shape
when the proxy must be the one controlled egress point for an otherwise disconnected
cluster. Select it with bnk.flp.mode: vsi:
bnk:
license_mode: f5licenseproxy
flp:
mode: vsi
vsi:
profile: bx2-4x16 # >= 4 vCPU / 16 GB
zone: us-south-1
reach: floating # "private" (VPC IP) or "floating" (public IP → egress to F5)
allowed_cidrs: [10.242.0.0/18] # sources allowed to reach the proxy (the cluster's workers)
roksbnkctl flp up then provisions the VSI; it terminates in the same flp-outputs.json
(endpoint + root CA) the Helm path produces, so bnk up consumes it unchanged.
Standalone — a licensing appliance in another VPC (no cluster)
By default the FLP VSI joins the cluster’s own VPC (from cluster-outputs.json), so
flp up requires a cluster. Give the proxy a network of its own — set bnk.flp.vsi.vpc to an existing VPC id, or bnk.flp.vsi.create_vpc: true to build one (mutually exclusive) — and flp up
deploys the proxy into that VPC with no cluster at all — a standalone licensing
appliance:
bnk:
license_mode: f5licenseproxy
flp:
mode: vsi
vsi:
vpc: r006-… # existing VPC id — deploy here, no cluster required
zone: us-south-1
reach: floating # the appliance's controlled egress to F5
allowed_cidrs: [10.0.0.0/8] # allow the consuming cluster's workers (e.g. over a TGW)
This is the piece that makes a genuinely disconnected topology clean: put Harbor +
the FLP in a services VPC that has egress, run the ROKS cluster in another VPC with
cluster.public_gateway: false (no worker egress — see
Chapter 10a §“A truly disconnected cluster”), join both
with a Transit Gateway, and point the cluster’s workspace at the proxy with
bnk.flp.external (its flp output endpoint + root CA). The cluster reaches Harbor and
the FLP privately over the TGW; all egress is concentrated in the services VPC, and
the cluster never phones home. A worked end-to-end script is in
disconnected_deployment_demo.sh.
# in a services workspace (no cluster) — deploy the standalone proxy, then read its handoff
$ roksbnkctl -w svc-flp flp up
$ roksbnkctl -w svc-flp flp output flp_external_endpoint
$ roksbnkctl -w svc-flp flp output flp_root_ca # → the disconnected cluster's bnk.flp.external
Tearing down
The FLP is an opt-in phase, so — exactly like gateway — the composite down
does not cover it. Tear it down first, while the cluster is still up:
roksbnkctl -w prod flp down # remove the proxy
roksbnkctl -w prod down # then BNK + the cluster (composite)
Both roksbnkctl down and cluster down refuse while FLP state exists, and
tell you to run flp down first. That guard is deliberate: the proxy’s Helm
release and secrets live in the cluster, so destroying the cluster out from
under them would strand state-flp/ pointing at resources that no longer exist,
and a later flp down could never reconcile.
flp down is a no-op success when there is no FLP state, so it is safe to put
unconditionally in a teardown script. Registered clusters are never destroyed —
flp down removes only the proxy workload.
Reference
| Config key | Meaning |
|---|---|
bnk.license_mode | connected (default), disconnected, or f5licenseproxy |
bnk.flp.namespace | namespace for the proxy (default f5-license-proxy) |
bnk.flp.chart_version | optional override. Left unset, the chart version is read from the BNK manifest (which lists charts/f5-license-proxy for the release), exactly like the FLO and CIS charts — you do not normally pin it. |
bnk.flp.node_port_access | expose the proxy outside its cluster (Flow C). Set by flp up --add-node-port-access; persisted so a later flp up does not tear the exposure down. |
bnk.flp.node_port_source_cidrs | with the above: the CIDRs allowed to reach the NodePort on the worker security group. A list — one address prefix per zone |
bnk.flp.external.url | license against a proxy in another cluster — its external_endpoint. This workspace never runs flp up. |
bnk.flp.external.root_ca_b64 | that proxy’s root_ca_b64, so the CWC can verify its certificate |
Flag (flp up) | Meaning |
|---|---|
--add-node-port-access | expose the proxy for other clusters: externalTrafficPolicy: Cluster, worker IPs as cert SANs, external endpoint recorded |
--node-port-source-cidr | open the NodePort to these CIDRs on the worker security group. Repeatable / comma-separated — pass every zone’s prefix |
| Environment variable | Overrides |
|---|---|
ROKSBNKCTL_LICENSE_MODE | bnk.license_mode |
ROKSBNKCTL_FLP_MODE | bnk.flp.mode ("" | helm | vsi) |
ROKSBNKCTL_FLP_EXTERNAL_URL | bnk.flp.external.url — license via a proxy in another cluster |
ROKSBNKCTL_FLP_ROOT_CA_B64 | bnk.flp.external.root_ca_b64 (verbatim; already base64) |
ROKSBNKCTL_FLP_VSI_CREATE_VPC | bnk.flp.vsi.create_vpc — give the proxy its own VPC |
ROKSBNKCTL_FLP_VSI_VPC_NAME | bnk.flp.vsi.vpc_name |
ROKSBNKCTL_FLP_VSI_SUBNET_CIDR | bnk.flp.vsi.subnet_cidr |
ROKSBNKCTL_FLP_VSI_VPC | bnk.flp.vsi.vpc — adopt an existing VPC (mutually exclusive with _CREATE_VPC) |
ROKSBNKCTL_FLP_VSI_ZONE / _PROFILE / _SSH_KEY / _BOOT_SIZE_GB / _REACH / _FLOATING_IP | the rest of bnk.flp.vsi.* |
ROKSBNKCTL_FLP_VSI_MANAGEMENT_ALLOWED_CIDRS / _LICENSING_ALLOWED_CIDRS | the two per-plane security-group lists (comma-separated) |
ROKSBNKCTL_FLP_NAMESPACE | bnk.flp.namespace |
| File | Written by | Read by |
|---|---|---|
~/.roksbnkctl/<ws>/flp-outputs.json | flp up | bnk up (FLP mode) — or copied into another workspace’s bnk.flp.external |
flp-outputs.json carries endpoint (in-cluster only) and, when exposed,
external_endpoint plus external_endpoints — every worker URL the proxy answers on.
All of them are IP SANs on its certificate, so any one is a valid
bnk.flp.external.url.