Helm
The Helm chart, report-server, runs Frontforge Report Server on Kubernetes: one reportd as a StatefulSet with a volume for /data, and renderd inside it or as its own Deployment. It runs the image docker.md describes, at the chart's version unless image.tag says otherwise, configured through REPORTD_ variables. From the folder that holds the chart:
helm install reports ./report-server -n reports --create-namespace
kubectl logs -n reports statefulset/reports-report-server | grep setupCodeThe first start is setup mode (setup.md): NOTES.txt prints how to get the setup code and reach the studio. admin.existingSecret skips it.
What it runs
- reportd: a StatefulSet with one replica and a PersistentVolumeClaim for
/data(persistence.size,persistence.storageClass), behind a Service on 43123.replicaCountabove 1 fails the install: the template store can't be shared yet. For more renders, userenderer.mode: separate. - Pod security: uid and gid 65532 with
fsGroup65532 (so the volume is writable),runAsNonRoot, a read-only root filesystem with anemptyDirfor/tmp, every capability dropped, no privilege escalation, and theRuntimeDefaultseccomp profile. renderd's pods run the same way. - Probes: liveness on
/livez; readiness on/readyz, which checks the engine and, on Postgres, the database; a startup probe allowing 10 minutes (startupProbe) for a data migration. - Ingress (
ingress.enabled):ingress.host,ingress.className,ingress.tlsSecretNameandingress.annotations.publicURLdefaults tohttps://<ingress.host>. helm testrunsreportd healthcheck --readyagainst the Service.
Settings
| Values | Become |
|---|---|
config | REPORTD_ variables, one per setting. Nested maps and dotted keys both make the path, so config: {logging: {format: json}} and config: {logging.format: json} are REPORTD_LOGGING_FORMAT; lists are comma-separated. |
configFile | /config/config.yaml, from a ConfigMap: for lists of objects, such as sign-in providers and connections, which variables can't hold. config wins over it. |
secrets | Keys of existing Secrets as files under /run/secrets/, for secret:file:<file> references: - {secretName: sso, key: client-secret, file: oidc-secret} and clientSecret: secret:file:oidc-secret in configFile. |
publicURL | REPORTD_PUBLICURL. |
admin.existingSecret, admin.passwordKey, admin.username | The first administrator's password from a Secret (secret:file:admin-password): no setup mode. |
state.postgres.existingSecret, urlKey | state.driver: postgres, with the connection URL from that Secret (state.md). No Postgres is bundled: use an operator or a managed service. |
state.postgres.existingKeysSecret | On Postgres every node must share auth.mfaKey and viewer.linkSecret: a Secret with mfa-key and link-key, or one the chart makes once and keeps (helm.sh/resource-policy: keep, since losing mfa-key loses every TOTP secret). |
serviceAccount.create, name, annotations, automount | The service account reportd runs as: one the chart makes (named after the release, or name), with annotations, or with create: false an existing one by name. automount (on, as Kubernetes' default) mounts its token, which Vault's kubernetes sign-in reads. See cloud identities. |
podLabels, podAnnotations | Labels and annotations on reportd's pod, beside the chart's own. |
extraEnv | More variables for reportd, as a container's env list (value or valueFrom). They come after the chart's own, so a name the chart sets is overridden. |
networkPolicy | A NetworkPolicy for reportd, off by default (below). |
existingSecret | A Secret you manage with every key the chart would otherwise make: mfa-key and link-key on Postgres, and renderd-token with renderer.mode: separate. The chart then makes no Secret. Required when the chart is rendered with helm template, as Argo CD does (below). state.postgres.existingKeysSecret and renderer.existingTokenSecret win over it. |
A setting the chart sets (the public URL, Postgres, the renderer) is shown as fixed in the setup wizard, with the variable it comes from.
The licence (licence.md) comes from a Secret through secrets and config:
secrets:
- {secretName: report-server-licence, key: licence, file: licence}
config:
licence: secret:file:licencestate.postgres.existingSecret and renderer.mode: separate are "scale" features (licence.md). A new install with them starts, but the setup wizard won't finish without a licence with scale. Setting the licence from a Secret, as above, avoids that step. Without them, the chart's defaults (one reportd, renderd inside it, no Postgres) run as Community.
Cloud identities
The secret plugins and data connections can sign in to Azure and AWS as the pod, with no key stored anywhere (data-connections.md). The chart sets the service account and the pod label each needs:
# AKS workload identity: a user-assigned managed identity (or app registration)
# federated with system:serviceaccount:<namespace>:<release>-report-server
serviceAccount:
annotations:
azure.workload.identity/client-id: "<the identity's client id>"
podLabels:
azure.workload.identity/use: "true"# EKS IAM roles for service accounts: a role whose trust policy names the
# service account
serviceAccount:
annotations:
eks.amazonaws.com/role-arn: arn:aws:iam::<account>:role/<role>The cluster's webhook then sets AZURE_CLIENT_ID, AZURE_TENANT_ID and AZURE_FEDERATED_TOKEN_FILE, or AWS_ROLE_ARN and AWS_WEB_IDENTITY_TOKEN_FILE, in reportd's pod. List the ones the plugin needs in its env (data-connections.md). The service account's name is <release>-report-server unless serviceAccount.name says otherwise. To use one made elsewhere (by Terraform, say), set serviceAccount.create: false and its name. EKS Pod Identity needs no annotation: its association names the service account. extraEnv sets anything else, such as the region for an AWS plugin, or a soft memory limit for Go:
extraEnv:
- name: AWS_REGION
value: eu-west-1
- name: GOMEMLIMIT
value: 1800MiBA NetworkPolicy for reportd
networkPolicy.enabled adds a NetworkPolicy that fences reportd's pod. It needs a network plugin that enforces policies, and it is off by default, since what reportd connects to depends on the install.
- In: reportd's port, from anywhere, or with
networkPolicy.ingressFrom(NetworkPolicy peers, such as the Ingress controller's namespace) only from those and the release's own pods (helm test). - Out: the cluster's DNS and, with
renderer.mode: separate, renderd. Everything else reportd uses must be listed innetworkPolicy.egressas NetworkPolicy egress rules: Postgres, sign-in providers, data sources, secret stores and cloud identity endpoints, template sources and the example gallery (github.com), and the update check.[{}]allows everything.
networkPolicy:
enabled: true
ingressFrom:
- namespaceSelector:
matchLabels: {kubernetes.io/metadata.name: ingress-nginx}
egress:
- to: [{ipBlock: {cidr: 10.0.20.0/24}}] # Postgres
ports: [{port: 5432, protocol: TCP}]
- to: [{ipBlock: {cidr: 0.0.0.0/0, except: [10.0.0.0/8, 169.254.0.0/16]}}]
ports: [{port: 443, protocol: TCP}] # sign-in providers, the gallery, the update checkNetworkPolicies match addresses, not names, so a service on the internet is best allowed by port, as above. reportd ignores HTTPS_PROXY, so an egress proxy is no way around that.
Argo CD and helm template
The chart keeps the keys it makes (mfa-key, link-key and the renderd token) by reading the live Secret with Helm's lookup. helm template has no cluster to read, so it makes new keys on every render. Argo CD renders charts that way, so each sync would replace them: TOTP sign-ins and shared links would stop working, and reportd and renderd could disagree on the token. Flux's helm-controller and helm install read the cluster, so they don't need this.
Under Argo CD, or anything else that renders with helm template, make the keys once yourself and name the Secret in existingSecret:
kubectl create secret generic report-server-keys -n reports \
--from-literal=mfa-key="$(openssl rand -base64 36)" \
--from-literal=link-key="$(openssl rand -base64 36)" \
--from-literal=renderd-token="$(openssl rand -base64 36)"# The Application's Helm values
helm:
valuesObject:
existingSecret: report-server-keys
state:
postgres:
existingSecret: report-server-postgres
renderer:
mode: separateKeep that Secret out of the Git repository Argo CD syncs from, or put it there sealed (Sealed Secrets, SOPS, or the External Secrets Operator reading your vault). Back it up: losing mfa-key loses every TOTP secret. A key the install doesn't use can be left out: renderd-token without renderer.mode: separate, mfa-key and link-key without Postgres.
To move an install made with helm install to Argo CD, copy the keys it already has into the new Secret rather than making new ones:
kubectl get secret reports-report-server-keys -n reports -o jsonpath='{.data.mfa-key}' | base64 -drenderd on its own
renderer:
mode: separate # inprocess (the default) or separate
replicas: 3
resources:
requests: {cpu: "1", memory: 512Mi}
limits: {cpu: "2", memory: 2Gi}
autoscaling:
enabled: true # a HorizontalPodAutoscaler on CPU; off by default
minReplicas: 2
maxReplicas: 8
targetCPUUtilizationPercentage: 70separateadds a renderd Deployment behind a headless Service. reportd looks its name up every 5 seconds and spreads renders over every ready pod (docker.md), so new pods get work as soon as they're ready.- Each pod's worker count follows its CPU limit. renderd's
/healthreports its workers, renders running and queue, for scaling on the queue. - The token renderd requires comes from a Secret the chart makes once and keeps,
renderd-tokeninexistingSecret, orrenderer.existingTokenSecret(keyrenderer.tokenKey). - A NetworkPolicy lets only reportd's pods reach renderd (
renderer.networkPolicy.enabled); it needs a network plugin that enforces policies. - Liveness and readiness run
renderd --healthcheck, which counts a busy renderd as up, so a busy pod isn't restarted or taken out of the Service.