Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Licensing BNK with the F5 License Proxy (FLP)

Field specs live in Chapter 28 — Configuration reference. That chapter is generated from the Workspace struct 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 — no flp phase, 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 runsUse it when
Flow Athe cluster roksbnkctl createsthe normal case
Flow Ba cluster you already own and registeryou did not provision the cluster
Flow Ca different cluster — one proxy serving manyonly 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 hardcodes externalTrafficPolicy: Local and runs one replica — so only the node currently hosting the pod answers, and that node changes when the pod reschedules. This flips it to Cluster, 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 with bad certificate.
  • Opens the port. ROKS workers sit in a kube-<cluster-id> security group that does not admit another cluster. --node-port-source-cidr opens 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-secret dockerconfig built from it, created in every namespace that pulls (cert-manager, the FLO/BNK namespaces, kube-system for 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 CNEManifest CR, 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 up time, so replacing a node in the services cluster means re-running flp up (which re-issues the cert) and updating the consuming workspace if you pinned the URL of the node that went away. flp output lists 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 flp phase at all — no state-flp/, nothing to tear down. bnk down there 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 keyMeaning
bnk.license_modeconnected (default), disconnected, or f5licenseproxy
bnk.flp.namespacenamespace for the proxy (default f5-license-proxy)
bnk.flp.chart_versionoptional 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_accessexpose 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_cidrswith the above: the CIDRs allowed to reach the NodePort on the worker security group. A list — one address prefix per zone
bnk.flp.external.urllicense against a proxy in another cluster — its external_endpoint. This workspace never runs flp up.
bnk.flp.external.root_ca_b64that proxy’s root_ca_b64, so the CWC can verify its certificate
Flag (flp up)Meaning
--add-node-port-accessexpose the proxy for other clusters: externalTrafficPolicy: Cluster, worker IPs as cert SANs, external endpoint recorded
--node-port-source-cidropen the NodePort to these CIDRs on the worker security group. Repeatable / comma-separated — pass every zone’s prefix
Environment variableOverrides
ROKSBNKCTL_LICENSE_MODEbnk.license_mode
ROKSBNKCTL_FLP_MODEbnk.flp.mode ("" | helm | vsi)
ROKSBNKCTL_FLP_EXTERNAL_URLbnk.flp.external.url — license via a proxy in another cluster
ROKSBNKCTL_FLP_ROOT_CA_B64bnk.flp.external.root_ca_b64 (verbatim; already base64)
ROKSBNKCTL_FLP_VSI_CREATE_VPCbnk.flp.vsi.create_vpc — give the proxy its own VPC
ROKSBNKCTL_FLP_VSI_VPC_NAMEbnk.flp.vsi.vpc_name
ROKSBNKCTL_FLP_VSI_SUBNET_CIDRbnk.flp.vsi.subnet_cidr
ROKSBNKCTL_FLP_VSI_VPCbnk.flp.vsi.vpc — adopt an existing VPC (mutually exclusive with _CREATE_VPC)
ROKSBNKCTL_FLP_VSI_ZONE / _PROFILE / _SSH_KEY / _BOOT_SIZE_GB / _REACH / _FLOATING_IPthe rest of bnk.flp.vsi.*
ROKSBNKCTL_FLP_VSI_MANAGEMENT_ALLOWED_CIDRS / _LICENSING_ALLOWED_CIDRSthe two per-plane security-group lists (comma-separated)
ROKSBNKCTL_FLP_NAMESPACEbnk.flp.namespace
FileWritten byRead by
~/.roksbnkctl/<ws>/flp-outputs.jsonflp upbnk 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.