Skip to content
stellwerk

stellwerk

One URL for every sender, one file for every rule, and an alarm when the alarms go quiet.

stellwerk receives webhooks from anything that can call a URL, decides by ordered rules what matters and where it goes, and delivers it end-to-end encrypted into Matrix rooms. It can also deliver by mail or ntfy and fall back to them when Matrix fails; here it runs Matrix only for now, and a delivery that finally fails stays visible in the audit log, from where it can be sent again. A heartbeat that stops arriving is an alarm of its own, and a daily canary proves the whole chain. It is one Go binary with a SQLite spool, written for exactly this homelab and published on its own.

It runs on the edge cluster, not at home, on purpose. Almost everything it reports about lives on talos: Alertmanager, Gatus, ntfy, the Proxmox hosts. A switchboard inside that cluster would go quiet together with it, which is the one failure that matters most. On the Hetzner node it keeps listening, and the missing Watchdog heartbeat turns a dead talos monitoring stack into a message instead of silence. The alerting topic shows where it sits among the other paths.

Alternatives considered

Before stellwerk, Alertmanager sent critical alerts to ntfy through a grafana-to-ntfy bridge and by mail, warnings went nowhere, every other app had its own notification settings screen, and all of it ran in the cluster it reported on.

Cloud Hosted

ToolOpen SourceFree TierMonthly Cost
Grafana OnCallPartlyYesFree tier; the open-source edition is archived, and alerts travel in plain text through Grafana Cloud
PagerDutyNoYesFree for a few users; on-call software for teams, every hostname and error message leaves the house
PushoverNoNoOne-off licence per platform; a delivery channel, no rules, no heartbeats

Self Hosted

ToolOpen SourceFull FeaturesNotes
Alertmanager routes + grafana-to-ntfyYesNoWhat ran before: covers metric alerts only, plain text to ntfy, nothing notices when it dies with the cluster
Apprise APIYesNoFans one message out to a hundred services, but has no rules engine, spool, fallback or heartbeat
GotifyYesNoA push server like ntfy; a destination, not a router

Installation

Architecture

  • Deployment: a single stellwerk Deployment in the stellwerk namespace, Recreate strategy, because the spool and the Matrix device stores are SQLite files on a ReadWriteOnce volume. The node ID is fixed (node_id: edge) instead of coming from the pod name, so a new pod opens the same device databases and stays the same Matrix device. Upstream ships a StatefulSet for the same reason and for high availability, which one node does not need
  • Image: ghcr.io/johnnycube/stellwerk, version and digest pinned, updated by Renovate. Built and signed keyless with cosign by the project’s GitHub release workflow
  • Configuration: three layers, each overriding the one before. The rules live in stellwerk.yaml in the edge overlay, turned into a hash-suffixed ConfigMap so a rule change rolls the pod. The SOPS Secret stellwerk holds one key per config path (sources.alertmanager.token, destinations.alarm.address) and is merged over the file; STELLWERK_WATCH reloads it within 30 seconds of a change
  • Storage: stellwerk-data, a 1Gi volume with the spool (spool.db), the audit file (audit.jsonl, rotated at 50MB) and one Matrix device database per account (matrix-<account>-edge.db)
  • Networking: two ports on one ClusterIP service, each with its own gateway. Port 8080 serves the ingest endpoints (/in/<source>, /ping/<name>, /ntfy, /gotify) and the health checks and nothing else; an HTTPRoute on the public gateway’s own stellwerk.web.domain.tld listener terminates TLS at Envoy. Port 8081 is a separate listener in stellwerk for the dataflow UI and its API, routed only through the edge cluster’s internal gateway as stellwerk.int.domain.tld, a record in NetBird’s int.domain.tld zone that only mesh members resolve and reach (NetBird). Keeping the two on separate listeners means no path rule on the public route can ever expose the UI
  • Probes: both on /healthz. /readyz answers 503 until every Matrix account has finished its first sync; as a readiness gate it would take the ingest endpoint off the Service exactly when matrix.org is down. Kept ready, stellwerk accepts and spools what arrives and delivers it once Matrix is back. Gatus watches /readyz from outside instead

Security

  • Every sender has its own credential. A token per source (Bearer, Basic auth password, ?token= or ntfy/Gotify token), or an HMAC-SHA256 signature for Flux (generic-hmac), whose key never travels. A leaked token can be rotated without touching the other senders. Requests with a wrong token are refused before routing and never reach the audit log
  • Messages are end-to-end encrypted. Both bots are cross-signed devices in encrypted rooms; stellwerk refuses to send into a room it does not know as encrypted. matrix.org sees who is in which room and when something is sent, never what.
  • Nothing identifying is in Git. Room IDs, the bot handles and the users allowed to invite them come from the Secret along with the tokens, so the public mirror carries the rules but not the addresses
  • Runs as 65532, runAsNonRoot: true, readOnlyRootFilesystem: true, all capabilities dropped, no ServiceAccount token, no service links
  • The UI needs the mesh and a password. Only the internal gateway’s Envoy may reach port 8081, and the UI asks for HTTP Basic auth with the password from the Secret (ui.password). The user name is free and goes into the audit log as ui:<name> for every silence set from the UI. Every changing call (silence, send again, reload, canary) also needs a custom header a cross-site form cannot set
  • Ingress on 8080 only from the public gateway’s Envoy and from the cluster’s Flux notification-controller, and on 8081 only from the internal gateway’s Envoy. Egress to public addresses on 443 (matrix.org, which sits behind a CDN), on top of the network-policy baseline

Updates

Managed by Renovate; the digest pin moves with the tag. The config is checked against the binary before it ships: stellwerk -check validates rules, templates and expressions, and stellwerk -test runs the tests: section through the real decoders and rules without sending anything. Run both with the new version before merging a bump that changes the config format, and read the changelog for renamed keys: an unknown key is an error, so a stale config fails loudly at start instead of being half applied.

Data Management

k8up backs up stellwerk-data to Hetzner every night. What matters in it are the Matrix device databases: without them and their pickle_key, a bot comes back as a new device that cannot read old messages and that every room has to trust again. The pickle keys are in the Secret and in Git, so a restored volume and the repository together bring the same devices back. The spool holds deliveries for minutes at most and the audit log is a convenience; neither is worth a restore on its own. The backup copies live SQLite files, so a restore can roll a device store back a few hours; the recovery key cross-signs the device again if Matrix complains.

Bootstrap

A new install needs two OpenTofu applies, two Matrix accounts and five rooms before the pod can deliver. Everything else is in Git.

  1. Apply the two pieces of infrastructure outside the cluster: ./tofu.sh apply in tofu/environment/edge creates the backup bucket, and in tofu/environment/netbird the record stellwerk.int.domain.tld for the UI.

  2. Register two accounts on matrix.org in Element, each with an e-mail address: the pager bot (account alerts) and the feed bot (account feed).

  3. Let stellwerk init log each bot in, set up cross-signing and create its first room. It writes the room ID into <dir>/stellwerk.yaml and the password and recovery key into <dir>/stellwerk.env. On matrix.org, identity changes run through its account service, so cross-signing can fail on the first try: init then prints a warning, leaves MATRIX_RECOVERY_KEY empty and still creates the room. Do not run init again, that makes a second room. Log in as the bot at account.matrix.org, allow the identity reset, and within its time window run stellwerk -config <dir>/stellwerk.yaml -bootstrap-cross-signing matrix/alerts with <dir>/stellwerk.env loaded; it prints the recovery key. The account is named alerts in both generated files, the feed bot’s too.

    stellwerk init -homeserver https://matrix-client.matrix.org -user @<pager-bot>:matrix.org \
      -invite @<you>:matrix.org,@<feed-bot>:matrix.org -room-name "Homelab · Alarm" -dir /tmp/sw-alerts
    stellwerk init -homeserver https://matrix-client.matrix.org -user @<feed-bot>:matrix.org \
      -invite @<you>:matrix.org -room-name "Homelab · GitOps" -dir /tmp/sw-feed

    When the rooms already exist, skip init: it always creates a room. Give each bot its cross-signing identity with a throwaway config instead, which logs in, prints the recovery key and creates nothing:

    # cs.yaml, run with: BOT_PASSWORD=… stellwerk -config cs.yaml -bootstrap-cross-signing matrix/alerts
    targets:
      matrix:
        type: matrix
        settings: { homeserver: https://matrix-client.matrix.org, database: "./{target}-{account}.db" }
        accounts:
          alerts: { user_id: "@<bot>:matrix.org", password: "${BOT_PASSWORD}", pickle_key: throwaway-local-key }
    sources: { local: { kind: generic, token: unused } }
    destinations: { none: { target: matrix, account: alerts, address: "!unused:matrix.org" } }
    routes: [ { name: none, to: none } ]
  4. In Element, create Homelab · Warnings (invite the pager bot), Homelab · Media and Homelab · Inbox (invite the feed bot), all encrypted. Set Alarm to notify on every message and the rest to mentions only.

  5. Put the values into the Secret, then delete /tmp/sw-*: the device keys in there belong to a throwaway device, the pod makes its own.

    f=k8s/apps/stellwerk/edge/secret-stellwerk.yaml
    sops set $f '["stringData"]["targets.matrix.accounts.alerts.user_id"]' '"@<pager-bot>:matrix.org"'
    sops set $f '["stringData"]["targets.matrix.accounts.alerts.password"]' '"…"'
    sops set $f '["stringData"]["targets.matrix.accounts.alerts.recovery_key"]' '"…"'
    # the same three for targets.matrix.accounts.feed
    sops set $f '["stringData"]["targets.matrix.settings.allowed_inviters"]' '"[\"@<you>:matrix.org\", \"@<pager-bot>:matrix.org\"]"'
    sops set $f '["stringData"]["destinations.alarm.address"]' '"!…:matrix.org"'
    # the same for warnings, gitops, media, misc
  6. Check the merged result with the image before pushing: stellwerk -print-config against the config file and a directory holding the decrypted keys must show an address for every Matrix destination and a user_id for both accounts, and stellwerk -test must pass.

The generated tokens, HMAC keys, pickle keys and the UI password are already in the Secret. -check passes without the bootstrap values, since an empty room is not a syntax error, but the bots cannot log in and nothing would be delivered; that is why step 5 reads the merged config instead.

Once Flux has applied it, prove the chain end to end before relying on it:

  1. Write !stellwerk status in Homelab · Alarm: the pager bot answers, encrypted. Then !stellwerk canary: the canary arrives, and the UI header shows it read back by the feed bot.
  2. Open the UI at stellwerk.int.domain.tld: every destination is green, and the alertmanager-watchdog heartbeat shows a recent beat, which proves Alertmanager reaches the public endpoint.
  3. Fire a test alert through Alertmanager (amtool alert add stellwerk-test severity=critical --alertmanager.url=https://alertmanager.talos.int.domain.tld, or a VMRule with vector(1)): it pages in Alarm, and its resolve follows quietly.
  4. Trigger a one-off k8up backup in the stellwerk namespace and check the snapshot holds matrix-alerts-edge.db, matrix-feed-edge.db and spool.db.

Administration

The dataflow UI at stellwerk.int.domain.tld is the place to look first; it needs NetBird and the password from the Secret, with any user name. It draws every source, rule and destination as a switchyard with live counters, and Try a payload shows which rule a body would hit and why, without sending anything. The Audit log has every received message with each rule’s verdict and every send attempt, until it was delivered or given up. When the mesh or the internal gateway is down, a port-forward reaches the same UI:

sops -d --extract '["stringData"]["ui.password"]' k8s/apps/stellwerk/edge/secret-stellwerk.yaml
kubectl -n stellwerk port-forward deploy/stellwerk 8081:8081   # then http://127.0.0.1:8081
  • Silences from the UI or from the alarm room: !stellwerk mute 2h source=proxmox -- cluster upgrade, !stellwerk silences, !stellwerk unmute <id>, !stellwerk status, !stellwerk canary. Only the pager bot answers commands, and only users in allowed_inviters may give them. A planned talos outage is !stellwerk mute 2h heartbeat=alertmanager-watchdog
  • Send again from an audit entry after a target was fixed; it goes to the destinations as configured now
  • Logs are JSON; every refused config names the key that failed. Once a minute stellwerk checks that each bot is in the rooms its destinations use, that those rooms are encrypted and that its device is cross-signed; a problem shows up in the destination’s detail in the UI
  • A new sender is a source with its own token (add it to the Secret), a rule, and a test case in stellwerk.yaml. The rule order is the policy: first match wins

Usage

The rooms

Five encrypted rooms on matrix.org, split by how soon a human has to act. Quiet messages arrive as notices that never push; loud ones notify.

RoomDestinationBotWhat lands there
Homelab · AlarmalarmpagerFiring critical alerts, a missing Watchdog, failures on edge, Gatus outages, Proxmox and Synology errors, the daily canary at 09:00
Homelab · WarningswarningspagerWarning alerts, resolved criticals, failed CI runs, Gatus recoveries, *arr health
Homelab · GitOpsgitopsfeedWhat Flux applied on both clusters, one digest per hour
Homelab · MediamediafeedDownloads and imports per hour, cleanuparr every six hours, new Seerr requests at once
Homelab · InboxmiscfeedScripts and anything no rule claims yet, which usually means a rule is missing

The two bots are separate on purpose. Each has its own login, queue and matrix.org rate limit, so a night of downloads never delays a page, and the feed bot sits in the alarm room to read the canary back: if it cannot decrypt it, encryption is broken even though the homeserver accepted the message.

The inputs

SourceSenderKind, credentialStatus
alertmanagervmalertmanager on talos, plus its Watchdog every minute as a heartbeatalertmanager, Bearer tokenWired: receiver stellwerk in alertmanager-config.yaml
flux-edgeFlux notification-controller on edge, in-clustergeneric, generic-hmac signatureWired: Provider/Alert in the app overlay
flux-talosFlux notification-controller on talosgeneric, generic-hmac signatureRepo change, see Flux on talos
gatusGatus on talosntfy, token tk_…Repo change, see Gatus
ciGitea Actions: a failure step in build-oci-apps and Renovategeneric, Bearer tokenGitea secret + repo change, see Gitea Actions
proxmoxthe Proxmox VE cluster, proxmox1–4gotify, app tokenIn the Proxmox UI, see Proxmox VE
synologyDS723+generic, ?token=In DSM, see Synology DSM
sonarr, radarr, lidarr, whisparr, prowlarrthe *arr appsgeneric, Basic auth passwordIn each app, see The *arr apps
seerrSeerrgeneric, Authorization headerIn Seerr, see Seerr
cleanuparrcleanuparrntfy, tokenIn cleanuparr, see cleanuparr
scriptsstellwerk send or curl from runbooks such as talos-upgrade.shgeneric, Bearer tokenReady, see Scripts

Every sender talks to https://stellwerk.web.domain.tld. Senders that can only speak ntfy or Gotify need nothing but a new server URL; the payload arrives as title, message, priority and tags.

Connecting the senders

Each source already has its own token (or HMAC key) in the Secret, so connecting a sender never touches stellwerk. Read a token with:

sops -d --extract '["stringData"]["sources.<source>.token"]' k8s/apps/stellwerk/edge/secret-stellwerk.yaml

Every sender’s Test button is the first check: the request shows up in the UI’s audit log with the rule that took it, and a refused token shows up nowhere (a 401 at the sender). Senders on talos reach the public endpoint through the edge IP, which the namespace network-policy baseline already allows on 443.

Gatus

A repo change in k8s/apps/gatus/talos/. Put the gatus token into a SOPS Secret in the Gatus overlay and hand it to the pod as an environment variable, then add the provider next to email in config/global.yaml:

alerting:
  ntfy:
    url: "https://stellwerk.web.domain.tld/ntfy"
    topic: "gatus"
    token: "${STELLWERK_NTFY_TOKEN}"   # Gatus refuses tokens without the tk_ prefix
    default-alert:
      failure-threshold: 3
      success-threshold: 2
      send-on-resolved: true

Endpoints opt in with alerts: [{type: ntfy}], which can sit next to type: email. Leave the Stellwerk endpoint on e-mail only: an alarm about stellwerk cannot go through stellwerk.

Flux on talos

A repo change, the same as the edge overlay’s flux/ directory but through the public endpoint: a Provider of type generic-hmac with address https://stellwerk.web.domain.tld/in/flux-talos, an Alert on the Kustomizations and sources in flux-system, and a Secret whose token is the value of sources.flux-talos.signature.secret, re-encrypted for the talos key. The rules keep talos Flux errors out of Alarm, since vmalert already pages for them.

Gitea Actions

In Gitea, add an Actions secret STELLWERK_TOKEN holding the ci token, on the johnny owner so every repository can use it (Settings → Actions → Secrets). Then give the workflows that matter a last step:

      - name: Tell stellwerk
        if: failure()
        run: |
          curl -fsS -H "Authorization: Bearer ${{ secrets.STELLWERK_TOKEN }}" \
            -d "{\"title\": \"${{ github.workflow }} failed\", \"message\": \"${{ github.repository }} run ${{ github.run_number }} on ${{ github.ref_name }}\"}" \
            https://stellwerk.web.domain.tld/in/ci

build-oci-apps comes first, since a broken run means neither cluster gets anything new; Renovate second.

Proxmox VE

Once for the whole cluster, since notification targets are cluster-wide configuration. Proxmox VE 8.1 or newer:

  1. Datacenter → Notifications → Notification Targets → Add → Gotify: name stellwerk, server https://stellwerk.web.domain.tld/gotify, API token = the proxmox token.
  2. Notification Matchers → Add: target stellwerk, matching severity warning and error, or everything if backup successes should land in Warnings too.
  3. Backup jobs need Notification mode: Notification system (Datacenter → Backup → Edit), or they keep mailing on their own.

Proxmox sends error as Gotify priority 8 or higher, which the proxmox-errors rule turns into an alarm. Check the first real message in the audit log; if Proxmox maps severities differently, adjust the threshold in that rule.

Synology DSM

In DSM 7.2: Control Panel → Notification → Webhook → Add, provider Custom:

  • URL https://stellwerk.web.domain.tld/in/synology?token=<synology token>, method POST, content type application/json
  • Body {"title": "Synology", "message": "@@TEXT@@"}, with @@TEXT@@ marked as the message parameter
  • Under Rules, pick the events: storage, backup (Hyper Backup, Snapshot Replication) and system health at least

The token sits in the URL here, which is why synology has a token of its own.

The *arr apps

In Sonarr, Radarr, Lidarr and Whisparr: Settings → Connect → + → Webhook. In Prowlarr: Settings → Notifications → + → Webhook.

  • URL https://stellwerk.web.domain.tld/in/<app> (sonarr, radarr, …), method POST
  • Username stellwerk (any name works), password = that app’s token
  • Triggers: grab, import/download, upgrade, health issue, health restored, application update, manual interaction required. Prowlarr only needs the health and update triggers

The Test event is dropped by the arr-tests rule, so it shows up in the audit log and nowhere else.

Seerr

Settings → Notifications → Webhook: enable it, URL https://stellwerk.web.domain.tld/in/seerr, Authorization Header Bearer <seerr token>, keep the default JSON payload (the rules read notification_type, subject and request.requestedBy_username from it). Select the request events: pending, approved, available, failed. Its test notification is dropped by the seerr-tests rule.

cleanuparr

Settings → Notifications → ntfy: server https://stellwerk.web.domain.tld/ntfy, topic cleanuparr, authentication with an access token = the cleanuparr token. Its messages arrive in Media every six hours.

Scripts

Runbooks and one-off scripts send with the stellwerk binary or plain curl; the message lands in Inbox:

export STELLWERK_URL=https://stellwerk.web.domain.tld STELLWERK_SOURCE=scripts
export STELLWERK_TOKEN=$(sops -d --extract '["stringData"]["sources.scripts.token"]' k8s/apps/stellwerk/edge/secret-stellwerk.yaml)
stellwerk send -title "talos-upgrade" "worker-02 upgraded"

After the trial

When stellwerk has carried the alerts for a few weeks, retire the old path: drop the ntfy and mail routes from alertmanager-config.yaml, then the grafana-to-ntfy bridge and its secrets. Until stellwerk has a channel that does not depend on matrix.org, those routes are the only path that survives a matrix.org outage, so add a mail target with fallback: on alarm before removing them.

The rules

The rules in k8s/apps/stellwerk/edge/stellwerk.yaml read top to bottom, and each has a test case at the bottom of the file:

  • Alertmanager: firing critical goes loud to Alarm with priority urgent, a resolved critical follows quietly into the same room, everything else goes to Warnings. The Watchdog never reaches a room: it is consumed as the heartbeat alertmanager-watchdog, and ten minutes without it is an alarm
  • Flux: errors on edge go loud to Alarm, because edge has no metrics stack and no other alarm. Talos errors already page through vmalert’s FluxReconciliationFailure, so both clusters’ events otherwise go to GitOps as an hourly digest
  • Hosts and probes: a Gatus message that says triggered goes loud to Alarm, its recovery to Warnings. Proxmox priority 8 and up, and Synology messages naming a failure, degradation or crash, go loud to Alarm; the rest of both to Warnings
  • CI: a failed run goes loud to Warnings, because a broken build-oci-apps means nothing reaches either cluster
  • Media: *arr test events are dropped, health events go to Warnings, the rest to Media as an hourly digest. A pending Seerr request is loud, since it waits for a decision
  • Catch-all: anything else lands in Inbox

Digests are held in memory: a clean shutdown sends them early, a crash loses them. That is why only noise is digested and nothing that pages.

Cluster-specific deviations from the above live in the per-cluster README — see k8s/apps/stellwerk/edge/README.md.

Cluster Deployment

stellwerk — Edge cluster

Deviations from defaults

  • Hostname inside the passthrough wildcard — stellwerk.web.domain.tld is covered by the *.web.domain.tld DNS record, so no record had to be added. The public-kueber gateway gives it its own HTTPS listener (https-stellwerk-web-kueber-eu) next to the web-tls passthrough to the home cluster, the way oci.web.domain.tld does for zot. Browsers that reuse a connection to another *.web.domain.tld site land on the home gateway, which answers 421 for this name (k8s/platform/configs/talos/envoy-gateway/http-route-misdirected-oci.yaml); a split-horizon DNS for *.web.domain.tld must leave this name alone, or talos would send its alerts to itself.
  • UI under int.domain.tld, not edge.int.domain.tld — stellwerk.int.domain.tld is an A record in the NetBird zone int.domain.tld (tofu/environment/netbird/dns.tf) pointing at the internal gateway’s LoadBalancer IP 172.30.0.11, inside the edge subnet NetBird routes to administrators. The gateway’s *.edge.int.domain.tld wildcard does not cover the name, so it has its own listener (https-stellwerk-int-kueber-eu) and certificate.
  • No metrics — metrics.listen is empty: edge runs no metrics stack to scrape them. Gatus on talos watches /readyz from outside and mails when it fails.
  • Flux events in-cluster — the Provider posts to the Service, not to the public hostname, so a broken gateway on this cluster can still report itself.
  • Backups at 04:00 — stellwerk-data goes to the Hetzner bucket workload-edge-stellwerk-f1bc803f (tofu/environment/edge/backups.tf), half an hour after seitenraum.

Kubernetes Metadata

  • Image: ghcr.io/johnnycube/stellwerk:0.1.0@sha256:0282f8aba03f1ab0d74a7bb1a313b90fbfc239c09dc6f48a3e2e2758207d33e8
Rendered manifests (kustomize build)
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/name: stellwerk
  name: stellwerk
  namespace: stellwerk
spec:
  replicas: 1
  revisionHistoryLimit: 2
  selector:
    matchLabels:
      app.kubernetes.io/name: stellwerk
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app.kubernetes.io/name: stellwerk
    spec:
      automountServiceAccountToken: false
      containers:
      - env:
        - name: STELLWERK_CONFIG
          value: /etc/stellwerk/config/stellwerk.yaml
        - name: STELLWERK_CONFIG_DIR
          value: /etc/stellwerk/secrets
        - name: STELLWERK_WATCH
          value: 30s
        - name: TZ
          value: Europe/Berlin
        image: 
          ghcr.io/johnnycube/stellwerk:0.1.0@sha256:0282f8aba03f1ab0d74a7bb1a313b90fbfc239c09dc6f48a3e2e2758207d33e8
        livenessProbe:
          httpGet:
            path: /healthz
            port: http
          initialDelaySeconds: 10
          periodSeconds: 20
        name: stellwerk
        ports:
        - containerPort: 8080
          name: http
        - containerPort: 8081
          name: ui
        readinessProbe:
          httpGet:
            path: /healthz
            port: http
          periodSeconds: 5
        resources:
          limits:
            memory: 256Mi
          requests:
            cpu: 20m
            memory: 64Mi
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            drop:
            - ALL
          readOnlyRootFilesystem: true
        volumeMounts:
        - mountPath: /etc/stellwerk/config
          name: config
          readOnly: true
        - mountPath: /etc/stellwerk/secrets
          name: secrets
          readOnly: true
        - mountPath: /data
          name: data
      enableServiceLinks: false
      securityContext:
        fsGroup: 65532
        runAsGroup: 65532
        runAsNonRoot: true
        runAsUser: 65532
        seccompProfile:
          type: RuntimeDefault
      terminationGracePeriodSeconds: 40
      volumes:
      - configMap:
          name: stellwerk-config-c2dt7kf6b7
        name: config
      - name: secrets
        secret:
          secretName: stellwerk
      - name: data
        persistentVolumeClaim:
          claimName: stellwerk-data
Last updated on