laboratory

module
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 6, 2026 License: Apache-2.0

README

Laboratory

Laboratory is the lab-infrastructure layer of the Cyber ICE Box platform. It runs isolated, per-team virtual networks on a Kubernetes cluster and gives each team access to its own lab over WireGuard or through an authenticated HTTPS front for web challenges.

It consists of:

  • a Kubernetes operator that reconciles a small CRD graph (Tenant, LabGroup, Lab, Device, Connection, LabGroupClient, Pool, plus a few internal kinds) into namespaces, pods, services and network policies, and schedules the start of pods;
  • a management agent, a gRPC API (mTLS) through which one or more platform backends (tenants) drive the operator, each seeing only its own objects;
  • a node-agent DaemonSet that programs Open vSwitch (OVS) on every node and plugs lab devices into L2 segments;
  • a WireGuard VPN server per lab group, reached through a shared VPN demultiplexer;
  • a shared L7 HTTPS proxy that fronts web challenges;
  • a per-group internet gateway (egress-only NAT, optional DHCP);
  • an optional platform registry (zot) that stores device state snapshots and works as a pull-through image cache;
  • a Helm chart that installs all of the above.

Architecture

                       platform backend
                             | gRPC + mTLS
                             v
                      +-------------+   CRDs    +-----------------+
                      |    agent    |---------->|    operator     |
                      +-------------+           | (controllers)   |
                                                +--------+--------+
                                                         | creates / reconciles
        participants                                     v
   +----------------------+        +----------------------------------------+
   | WireGuard client     |  UDP   |  namespace labgroup-<id> (one per team)|
   |                      |------->|  +-------------+   +-----------------+ |
   +----------------------+   |    |  | VPN server  |   | internet gateway| |
   | browser (web tasks)  |   |    |  +------+------+   +--------+--------+ |
   +-----------+----------+   |    |         |  lab networks   |           |
               | TCP 443      |    |     +---+-----------------+---+       |
               v              |    |     |  device pods (attacker, |       |
   +-----------------------+  |    |     |  targets, switches ...) |       |
   | laboratory-proxy      |  |    |     +-------------------------+       |
   |  - proxy-l7 (HTTPS)   |--+--->+----------------------------------------+
   |  - proxy-wg (demux)   |            ^
   +-----------------------+            | OVS L2 segments, Geneve between nodes
                                +-------+--------+
                                |   node-agent   |  (DaemonSet: OVS sidecar, CNI gate,
                                +----------------+   device port reconciler)
  • A Tenant is a client of the management agent (a platform backend). Tenants are isolated from each other and have their own device-persistence policy and resource quota (see Tenancy).
  • A LabGroup is one team (or any unit of isolation) of a tenant. It gets its own namespace, WireGuard server, internet gateway and address space. Lab networks of different groups are isolated from each other.
  • A Lab declares devices and connections between them. The operator materialises Device pods and Connection segments; the node-agent plugs each device into an OVS L2 segment, across nodes if needed.
  • A LabGroupClient is one WireGuard peer. The operator generates its key pair and a ready-to-use client config.
  • Pool objects allocate VNIs, IPs and lab subnets.
  • The proxy runs two containers on one public IP. proxy-wg demultiplexes incoming WireGuard UDP to the right group's VPN server without terminating VPN traffic. proxy-l7 terminates TLS for *.<baseDomain>, verifies the participant's session (seeded from a lab access link: a JWT signed with the Ed25519 access key of the tenant that owns the lab group) and routes the request to the challenge's web service.

Components

Component Image Role
manager (operator) laboratory-controller controller-runtime manager with all reconcilers
agent laboratory-agent gRPC management API (LabManager) in front of the CRDs
node-agent laboratory-node per-node OVS programming, device port reconciliation, gRPC socket for the CNI gate
install-cni, cni-gate laboratory-node installs and runs the meta-CNI that keeps the cluster CNI in charge of eth0
netconfig laboratory-node init container that configures lab interfaces inside a device pod
vpn laboratory-lab per-group WireGuard server, peer management, access policy, flow accounting
gateway laboratory-lab per-group internet egress NAT and optional DHCP for lab segments
proxy-l7, proxy-wg laboratory-proxy shared HTTPS front and WireGuard demultiplexer
ovs-diag - diagnostic tool for moving OVS ports into pod network namespaces

The single Dockerfile in the repository root builds all images (--target controller|agent|proxy|node|lab). Component specifications (in Russian) are in docs/specs/.

Releases & images

Images are published to Docker Hub for linux/amd64 and linux/arm64:

Image Contents Base Target of Dockerfile
cybericebox/laboratory-controller operator (/manager) distroless static controller
cybericebox/laboratory-agent gRPC management API (/agent) distroless static agent
cybericebox/laboratory-proxy /proxy with proxy-l7 and proxy-wg distroless static proxy
cybericebox/laboratory-node /node (node-agent, install-cni, netconfig, cni-gate), Open vSwitch, CNI plugins alpine 3.24 node
cybericebox/laboratory-lab /lab (vpn, gateway), iptables (nft), iproute2, wg alpine 3.24 lab

Each image carries only the code of its own domain. The proxy, node and lab binaries start the component named by their first argument (/node node-agent); the cni-gate copy the node-agent installs on the host is the node binary started under that name. Open vSwitch is 3.7.1 from alpine 3.24; OVS 4.0.0 arrives with the next alpine stable release (we do not use edge).

  • The cycle (PR check, develop, pre-release, promote) is described in CONTRIBUTING.md. A merge into develop publishes sha-<7> of every image (develop.yml); a merge into main publishes vX.Y.Z-rc.N (prerelease.yml).
  • Promoting an rc (promote.yml) adds vX.Y.Z and latest to the same images without a rebuild, packages the Helm chart with version X.Y.Z and appVersion vX.Y.Z, pushes it to oci://registry-1.docker.io/cybericebox/laboratory and attaches the .tgz to the GitHub release.
  • Chart image tags default to the chart appVersion (vX.Y.Z); set *.image.tag in values to pin another exact tag (for example sha-<short commit>). The chart refuses latest.
helm install laboratory oci://registry-1.docker.io/cybericebox/laboratory --version X.Y.Z \
  --namespace laboratory-system --create-namespace -f my-values.yaml

The workflows need two repository secrets (Settings, Secrets and variables, Actions): DOCKERHUB_USERNAME and DOCKERHUB_TOKEN (a Docker Hub access token with write access to the cybericebox organisation).

Requirements

Laboratory targets bare Linux VMs running Kubernetes (developed against k0s).

  • Kubernetes with the Gateway API and Cilium as the cluster CNI (the chart creates a Cilium Gateway with TLS passthrough and shares one load-balancer IP between the Gateway and the WireGuard service through Cilium LB-IPAM). A kind cluster works for local development.
  • Node kernel (cgroup v2) with these modules available: openvswitch, geneve, wireguard, br_netfilter, nf_conntrack, nf_conntrack_netlink. Nothing else has to be installed on the host: Open vSwitch runs inside the node-agent DaemonSet (an ovs sidecar), and a host-prep init container loads the modules and sets the required sysctls.
  • cert-manager (chart dependency) for the proxy wildcard certificate, the agent's server certificate and the client CA of the agent. Tenant client certificates are not issued by cert-manager: the agent signs them when a tenant enrolls (see Tenancy). With an ACME issuer the wildcard certificate needs a DNS-01 solver (Cloudflare is supported by the chart); a self-signed issuer is available for development.
  • Kubernetes 1.33+ (the chart refuses an older cluster: user namespaces for device pods, spec.hostUsers), containerd 2.x and a node kernel 6.3+ for them; kubectl 1.33+, helm 3.12+.
  • To build from source: the Go version in go.mod, Docker, and make.

Quick start (Helm)

The chart is in charts/laboratory. It must be installed into the laboratory-system namespace; templates/validate.yaml rejects anything else and fails early when a required value is missing.

  1. Create the namespace. Lab access links are signed by the tenant's own access key, registered when the tenant enrolls (Enrollment & access keys); there is no shared key to create.

    kubectl create namespace laboratory-system
    
  2. Create the proxy session secret (32+ bytes) in the proxy namespace:

    kubectl create namespace laboratory-proxy
    kubectl -n laboratory-proxy create secret generic proxy-session \
      --from-literal=sessionSecret="$(openssl rand -base64 48)"
    
  3. If your images are in a private registry, create kubernetes.io/dockerconfigjson secrets in laboratory-system (and in laboratory-proxy / laboratory-agent, which run in their own namespaces) and list them under imagePullSecrets. The operator copies them into every lab group namespace.

  4. Write a values file:

    # my-values.yaml
    operator:
      baseDomain: lab.example.com                  # REQUIRED: base domain of lab web hosts
      publicVPNEndpoint: vpn.example.com            # REQUIRED: host (or host:port) handed to WireGuard clients; the port is proxy.wg.publicPort, 51820 by default
      supportEmail: support@example.com            # shown on the VPN probe page
    agent:
      enabled: true                                # its host is ctl.<baseDomain> unless agent.domain is set
    proxy:
      wg:
        nodePort: 31820                            # optional fixed NodePort of the WireGuard service
    tenants:
      platform: { }                                # one Tenant per platform backend; its name is the certificate CN
    imagePullSecrets:
      - name: registry-credentials
    

    These are the only values an installation has to give (and certManager.email with an ACME issuer). One release tag drives every image (image.tag, empty = the chart appVersion); everything else has a default that suits any installation and stays overridable. All options are documented in charts/laboratory/values.yaml; only the ports inside the cluster network are constants of the images, they are listed in DEPLOY.md ("The inputs"). The port clients connect to outside the cluster is proxy.wg.publicPort (51820 by default).

  5. Install:

    helm dependency update charts/laboratory
    helm install laboratory charts/laboratory \
      --namespace laboratory-system --create-namespace \
      -f my-values.yaml
    
  6. Hand the tenant its enrollment token and let its backend enroll (see Tenancy and enrollment):

    kubectl -n laboratory-tenants get secret tenant-platform-enrollment -o jsonpath='{.data.token}' | base64 -d
    
  7. For direct use without a backend, create a lab group and a lab. DEPLOY.md walks through LabGroup, LabGroupClient and Lab examples, upgrades and uninstalling (CRDs are not removed by helm uninstall).

Scheduler

A burst of new Labs and LabGroups does not start all at once. The scheduler starts their pods through a window (scheduler.maxPods, 20 by default), one object after another (the pod-slot conveyor). Objects with the same deploy group are started together, and a group can declare other groups that must complete first (deploy-after). A pod that is not Ready within scheduler.startupTimeout (5 minutes) is declared failed with a warning and a reason (ImagePull, CrashLoop, Unschedulable, StartupTimeout, PodNotCreated, DoesNotFit) and frees its slot. Before a group starts, its images are pulled onto the nodes by the node-agents through the container runtime (an ImagePull request; no tenant code runs); a prepull gates only its own group and gives up at once on an image that cannot be pulled. A pod is held back while no node has room for it, and while its tenant is at its resource quota. Device pods are Guaranteed (requests equal limits) and each lab group has a PodDisruptionBudget. The queue place and reason are in status.scheduling and in the agent's LabStatus.queue. See "Scheduler" in DEPLOY.md.

Tenancy and enrollment

One cluster serves several backends (tenants) that must not see each other.

  • A tenant is a cluster-scoped Tenant resource, declared in the chart's tenants: values (the tenant default always exists). It carries the device-persistence policy (persistence.allowed, writeQuota, maxFileSize) and an optional CPU and memory quota (absolute or a percentage of what the lab nodes allocate). The agent stamps every object it creates with the tenant, so every RPC sees only the caller's objects; another tenant's object is NOT_FOUND. GetCapacity and the Monitoring stream report only the caller's quota, reserved and used resources.
  • The tenant identity is the CN of the client certificate. The tenant never receives a private key from the cluster. The operator creates a one-time enrollment token per tenant (Secret tenant-<name>-enrollment in laboratory-tenants); the cluster administrator hands it over. The tenant calls Enroll (plain TLS, no client certificate yet) with the token, a certificate request and the public half of its own Ed25519 access key; the agent signs a client certificate (CN = the tenant name) and burns the token. Afterwards the tenant calls RenewCertificate, RotateAccessKey and RemoveAccessKey over mTLS.
  • Lab access links are JWTs signed by the tenant with its access key (iss = tenant, kid = key id, aud = laboratory-proxy, sub = the VPN client, nbf/exp). The proxy reads the public keys of all tenants from laboratory-tenants and also checks that the lab group belongs to the issuer. There is no key shared between tenants.

Details, limits and the manual fallback are in DEPLOY.md.

Device state, image cache and group overhead

  • Device state persistence (optional, devices.statePersistence.enabled): the writable layer of a device survives a crash or node loss. Each device chooses it in its topology (persistence.enabled, debounce); the cluster and the tenant policy bound it (writeQuota, maxFileSize, excludePaths). Snapshots go to the platform registry; the agent can export the latest state of a device as one archive (ExportDeviceSnapshot). See Device state persistence and Snapshot export.
  • Image cache (optional, registry.cache.enabled): zot is a pull-through cache for the images of labs. The operator pins the digest of each image when a lab is created, so a moving tag cannot change an image during an event, and the agent can prewarm the cache before an event (PrewarmImages). See Image cache.
  • Group overhead: every lab group runs a VPN pod and a gateway pod; their resources are chart values (vpn.resources, inetGateway.resources, Guaranteed) and GetCapacity reports their sum (group_overhead_cpu_millicores, group_overhead_memory_bytes) for sizing a reservation.

Domains

Three names are set by configuration (chart values); the agent's has a derived default:

Name Value Points to
*.<operator.baseDomain> for example *.labs.<zone> the L7 proxy; web devices are <device>-<code>.<baseDomain>
operator.publicVPNEndpoint for example vpn.<zone>:51820 the WireGuard demultiplexer
agent.domain default ctl.<operator.baseDomain> the management agent (gRPC, TLS)

See docs/specs/domains.md (Russian) for the naming rules and the planned region sub-domains.

Management agent API

With agent.enabled, the chart deploys a gRPC server (default port 5454, TLS with mutual authentication; the tenant is the CN of the client certificate, obtained by enrolling, see Tenancy and enrollment). The service is LabManager, defined in pkg/agent/protobuf/agent.proto. The CRUD API is plural-only (every call takes a list; one object is a list of one): CreateLabGroups / ListLabGroups / UpdateLabGroups / DeleteLabGroups, the same four for LabGroupClients and Labs, SetLabGroupAccess (access policies of many groups), ResetDevices / RescueDevices, ExportDeviceSnapshot, the enrollment calls Enroll / RenewCertificate / RotateAccessKey / RemoveAccessKey, plus Ping, GetCapacity, PrewarmImages and a resumable, label-selectable Monitoring stream (see Monitoring stream). Every mutating call answers with a per-item result, takes labels (request-level and per item), and selector calls are guarded by expected_count. The full list, the rules and examples are in Management agent API; device state calls are in Device state persistence. Lab.scheduling and LabGroup.scheduling carry the scheduler state. Go bindings are generated next to the proto file; a Go client is in pkg/agent/client.

Development

make help            # list all targets
make manifests       # regenerate CRDs and RBAC (controller-gen)
make generate        # regenerate deepcopy code
make fmt vet         # format and vet
make lint            # golangci-lint (downloaded into ./bin)
make build           # build the operator binary into ./bin/manager
make test            # unit and envtest tests; writes cover.out
make test-e2e        # e2e tests against a kind cluster (see test/e2e)
  • Tests. make test downloads the kube-apiserver and etcd binaries with setup-envtest into ./bin and runs every package except the e2e suite, so controller tests run against a real API server without a cluster. Chart rendering tests live in test/chart.
  • Images. make docker-build builds all five images (make docker-build-controller|agent|proxy|node|lab one of them); make kind-deploy builds them, loads them into a kind cluster and installs everything.
  • Clients. Typed clientset and apply configurations are generated with hack/update-codegen.sh.
  • Local cluster. The Makefile expects the local k0s/Lima cluster kit (VMs, Cilium Gateway, test scenarios) in a sibling infrastructure repository, configured by LOCAL_K0S (default ../infrastructure/local/cluster).

Documentation

License

Licensed under the Apache License, Version 2.0. See LICENSE.

Directories

Path Synopsis
api
allocation/v1alpha1
Package v1alpha1 contains API Schema definitions for the allocation v1alpha1 API group.
Package v1alpha1 contains API Schema definitions for the allocation v1alpha1 API group.
laboratory/v1alpha1
Package v1alpha1 contains API Schema definitions for the laboratory v1alpha1 API group.
Package v1alpha1 contains API Schema definitions for the laboratory v1alpha1 API group.
clientset
client/versioned/fake
This package has the automatically generated fake clientset.
This package has the automatically generated fake clientset.
client/versioned/scheme
This package contains the scheme of the automatically generated clientset.
This package contains the scheme of the automatically generated clientset.
client/versioned/typed/allocation/v1alpha1
This package has the automatically generated typed clients.
This package has the automatically generated typed clients.
client/versioned/typed/allocation/v1alpha1/fake
Package fake has the automatically generated clients.
Package fake has the automatically generated clients.
client/versioned/typed/laboratory/v1alpha1
This package has the automatically generated typed clients.
This package has the automatically generated typed clients.
client/versioned/typed/laboratory/v1alpha1/fake
Package fake has the automatically generated clients.
Package fake has the automatically generated clients.
cmd
agent command
agent is the gRPC management API image's binary.
agent is the gRPC management API image's binary.
lab command
lab is the per-lab-group image's binary: the VPN server and the internet gateway.
lab is the per-lab-group image's binary: the VPN server and the internet gateway.
manager command
manager is the operator image's binary.
manager is the operator image's binary.
node command
node is the per-node image's binary: node-agent, install-cni, netconfig and cni-gate.
node is the per-node image's binary: node-agent, install-cni, netconfig and cni-gate.
ovs-diag command
ovs-diag checks each step of moving an OVS internal port into a pod netns, comparing the library approach (vishvananda/netlink+netns) with the CLI (ip / nsenter).
ovs-diag checks each step of moving an OVS internal port into a pod netns, comparing the library approach (vishvananda/netlink+netns) with the CLI (ip / nsenter).
proxy command
proxy is the internet-facing image's binary: `proxy proxy-l7` and `proxy proxy-wg`.
proxy is the internet-facing image's binary: `proxy proxy-l7` and `proxy proxy-wg`.
internal
accessroute
Package accessroute keeps the access port of a web-exposed device pod out of the pod's main routing table.
Package accessroute keeps the access port of a web-exposed device pod out of the pod's main routing table.
admissioncheck
Package admissioncheck lets the operator verify, before it works, that the chart's admission policies are really enforced on its ServiceAccount.
Package admissioncheck lets the operator verify, before it works, that the chart's admission policies are really enforced on its ServiceAccount.
cmds/netconfig
netconfig is the device init-container helper.
netconfig is the device init-container helper.
crdcheck
Package crdcheck lets the agent and the operator refuse to start against CRDs that are older than they are.
Package crdcheck lets the agent and the operator refuse to start against CRDs that are older than they are.
deviceplugin
Package deviceplugin is the kubelet device plugin of the node-agent.
Package deviceplugin is the kubelet device plugin of the node-agent.
devices
Package devices names and finds the Device objects of a lab.
Package devices names and finds the Device objects of a lab.
devicestate
Package devicestate is the node-agent side of device state persistence: it follows the snapshot-backed device containers of a node, detects changes of their writable layer, and turns them into snapshot images in the platform registry.
Package devicestate is the node-agent side of device state persistence: it follows the snapshot-backed device containers of a node, detects changes of their writable layer, and turns them into snapshot images in the platform registry.
egress
Package egress holds what a lab can never reach through its internet gateway.
Package egress holds what a lab can never reach through its internet gateway.
errorlog
Package errorlog is the laboratory's own error journal: every component (operator, node-agent, L7 proxy, wg-demux, VPN and gateway pods, the agent) counts its errors by a normalized fingerprint, keeps a few recent messages and publishes the aggregate as a Kubernetes Event that the management agent reads and forwards in MonitoringUpdate.errors.
Package errorlog is the laboratory's own error journal: every component (operator, node-agent, L7 proxy, wg-demux, VPN and gateway pods, the agent) counts its errors by a normalized fingerprint, keeps a few recent messages and publishes the aggregate as a Kubernetes Event that the management agent reads and forwards in MonitoringUpdate.errors.
grouppods
Package grouppods holds the resources of the pods a LabGroup runs itself, the VPN and the internet gateway.
Package grouppods holds the resources of the pods a LabGroup runs itself, the VPN and the internet gateway.
health
Package health holds the readiness checks the platform's processes share: "ready" means the process really serves (its listener is up and its informer caches have synced), not merely that it started.
Package health holds the readiness checks the platform's processes share: "ready" means the process really serves (its listener is up and its informer caches have synced), not merely that it started.
imagecache
Package imagecache rewrites image references so the nodes pull them through the platform's in-cluster pull-through cache (zot with on-demand sync).
Package imagecache rewrites image references so the nodes pull them through the platform's in-cluster pull-through cache (zot with on-demand sync).
imagepolicy
Package imagepolicy decides whether a tenant may use an image: a per-tenant allow list and a platform deny list of "registry/repository-prefix" entries, and the refusal of references that already point at the platform's image cache.
Package imagepolicy decides whether a tenant may use an image: a per-tenant allow list and a platform deny list of "registry/repository-prefix" entries, and the refusal of references that already point at the platform's image cache.
imagepull
Package imagepull pulls images onto a node through the container runtime's image service (CRI), for the node-agent.
Package imagepull pulls images onto a node through the container runtime's image service (CRI), for the node-agent.
limits
Package limits holds the caps the cluster owns on devices, labs and tenants.
Package limits holds the caps the cluster owns on devices, labs and tenants.
multicall
Package multicall routes one binary to several components of the same domain: the first argument selects the component, or the name the binary is invoked as (for example the cni-gate copy that the node-agent installs on the host).
Package multicall routes one binary to several components of the same domain: the first argument selects the component, or the name the binary is invoked as (for example the cni-gate copy that the node-agent installs on the host).
netattach
Package netattach holds the rules of the device network interfaces and the encoding of the network.cybericebox.com/networks pod annotation shared by the operator (writer), the management agent (validation) and the node-agent (reader).
Package netattach holds the rules of the device network interfaces and the encoding of the network.cybericebox.com/networks pod annotation shared by the operator (writer), the management agent (validation) and the node-agent (reader).
nodeagent/ofclient
Package ofclient implements a minimal OpenFlow 1.3 client over a Unix socket.
Package ofclient implements a minimal OpenFlow 1.3 client over a Unix socket.
nodecap
Package nodecap holds the node eligibility rule shared by the operator's scheduler and the management agent: which nodes lab pods can run on.
Package nodecap holds the node eligibility rule shared by the operator's scheduler and the management agent: which nodes lab pods can run on.
nstest
Package nstest builds small network topologies out of Linux network namespaces for tests of real iptables rules.
Package nstest builds small network topologies out of Linux network namespaces for tests of real iptables rules.
podinput
Package podinput is the INPUT policy of the VPN pod and the internet gateway pod.
Package podinput is the INPUT policy of the VPN pod and the internet gateway pod.
profiles
Package profiles is the fixed catalog of device security profiles.
Package profiles is the fixed catalog of device security profiles.
reconcileutil
Package reconcileutil holds what every controller of the operator and the node-agent shares.
Package reconcileutil holds what every controller of the operator and the node-agent shares.
snapshot
Package snapshot holds the platform-independent logic of device state persistence: which paths are kept, the size quota, the layer chain rules and the tar plumbing that filters and squashes snapshot layers.
Package snapshot holds the platform-independent logic of device state persistence: which paths are kept, the size quota, the layer chain rules and the tar plumbing that filters and squashes snapshot layers.
status
Package status provides shared helpers for setting Kubernetes-style status Conditions and emitting Events, so reconciler wait/failure states are visible via `kubectl describe` instead of being silent forever-requeues.
Package status provides shared helpers for setting Kubernetes-style status Conditions and emitting Events, so reconciler wait/failure states are visible via `kubectl describe` instead of being silent forever-requeues.
tenant
Package tenant holds the pure rules of the Tenant resource shared by the management agent and the operator: the quota (absolute or percent) and the persistence limits.
Package tenant holds the pure rules of the Tenant resource shared by the management agent and the operator: the quota (absolute or percent) and the persistence limits.
vpn
vpn/flowacct
Package flowacct counts, and never inspects, the connections that VPN clients open to the lab networks of one group.
Package flowacct counts, and never inspects, the connections that VPN clients open to the lab networks of one group.
pkg
agent/client
Package client is a thin, ready-to-use gRPC client for the LabManager agent.
Package client is a thin, ready-to-use gRPC client for the LabManager agent.
runtime
Package runtime configures Go runtime parameters for containerised deployments.
Package runtime configures Go runtime parameters for containerised deployments.
statuspage
Package statuspage is the one look of the small static pages the laboratory serves to a browser: the VPN check page inside the tunnel and the proxy's error cards.
Package statuspage is the one look of the small static pages the laboratory serves to a browser: the VPN check page inside the tunnel and the proxy's error cards.
tlsreload
Package tlsreload serves certificates that cert-manager renews in place: the key pair and the CA bundle are re-read from the mounted files when they change, so a renewal never needs a pod restart.
Package tlsreload serves certificates that cert-manager renews in place: the key pair and the CA bundle are re-read from the mounted files when they change, so a renewal never needs a pod restart.
vpnprobe
Package vpnprobe defines the address of the tunnel-only connection check.
Package vpnprobe defines the address of the tunnel-only connection check.
test

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL