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
| Tool | Open Source | Free Tier | Monthly Cost |
|---|---|---|---|
| Grafana OnCall | Partly | Yes | Free tier; the open-source edition is archived, and alerts travel in plain text through Grafana Cloud |
| PagerDuty | No | Yes | Free for a few users; on-call software for teams, every hostname and error message leaves the house |
| Pushover | No | No | One-off licence per platform; a delivery channel, no rules, no heartbeats |
Self Hosted
| Tool | Open Source | Full Features | Notes |
|---|---|---|---|
| Alertmanager routes + grafana-to-ntfy | Yes | No | What ran before: covers metric alerts only, plain text to ntfy, nothing notices when it dies with the cluster |
| Apprise API | Yes | No | Fans one message out to a hundred services, but has no rules engine, spool, fallback or heartbeat |
| Gotify | Yes | No | A push server like ntfy; a destination, not a router |
Installation
Architecture
- Deployment: a single
stellwerkDeployment in thestellwerknamespace,Recreatestrategy, 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.yamlin the edge overlay, turned into a hash-suffixed ConfigMap so a rule change rolls the pod. The SOPS Secretstellwerkholds one key per config path (sources.alertmanager.token,destinations.alarm.address) and is merged over the file;STELLWERK_WATCHreloads 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 ownstellwerk.web.domain.tldlistener 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 asstellwerk.int.domain.tld, a record in NetBird’sint.domain.tldzone 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./readyzanswers 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/readyzfrom 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 asui:<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.
Apply the two pieces of infrastructure outside the cluster:
./tofu.sh applyintofu/environment/edgecreates the backup bucket, and intofu/environment/netbirdthe recordstellwerk.int.domain.tldfor the UI.Register two accounts on matrix.org in Element, each with an e-mail address: the pager bot (account
alerts) and the feed bot (accountfeed).Let
stellwerk initlog each bot in, set up cross-signing and create its first room. It writes the room ID into<dir>/stellwerk.yamland 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:initthen prints a warning, leavesMATRIX_RECOVERY_KEYempty and still creates the room. Do not runinitagain, that makes a second room. Log in as the bot at account.matrix.org, allow the identity reset, and within its time window runstellwerk -config <dir>/stellwerk.yaml -bootstrap-cross-signing matrix/alertswith<dir>/stellwerk.envloaded; it prints the recovery key. The account is namedalertsin 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-feedWhen 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 } ]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.
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, miscCheck the merged result with the image before pushing:
stellwerk -print-configagainst the config file and a directory holding the decrypted keys must show an address for every Matrix destination and auser_idfor both accounts, andstellwerk -testmust 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:
- Write
!stellwerk statusin 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. - Open the UI at
stellwerk.int.domain.tld: every destination is green, and thealertmanager-watchdogheartbeat shows a recent beat, which proves Alertmanager reaches the public endpoint. - Fire a test alert through Alertmanager (
amtool alert add stellwerk-test severity=critical --alertmanager.url=https://alertmanager.talos.int.domain.tld, or a VMRule withvector(1)): it pages in Alarm, and its resolve follows quietly. - Trigger a one-off k8up backup in the
stellwerknamespace and check the snapshot holdsmatrix-alerts-edge.db,matrix-feed-edge.dbandspool.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 inallowed_invitersmay 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.
| Room | Destination | Bot | What lands there |
|---|---|---|---|
| Homelab · Alarm | alarm | pager | Firing critical alerts, a missing Watchdog, failures on edge, Gatus outages, Proxmox and Synology errors, the daily canary at 09:00 |
| Homelab · Warnings | warnings | pager | Warning alerts, resolved criticals, failed CI runs, Gatus recoveries, *arr health |
| Homelab · GitOps | gitops | feed | What Flux applied on both clusters, one digest per hour |
| Homelab · Media | media | feed | Downloads and imports per hour, cleanuparr every six hours, new Seerr requests at once |
| Homelab · Inbox | misc | feed | Scripts 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
| Source | Sender | Kind, credential | Status |
|---|---|---|---|
alertmanager | vmalertmanager on talos, plus its Watchdog every minute as a heartbeat | alertmanager, Bearer token | Wired: receiver stellwerk in alertmanager-config.yaml |
flux-edge | Flux notification-controller on edge, in-cluster | generic, generic-hmac signature | Wired: Provider/Alert in the app overlay |
flux-talos | Flux notification-controller on talos | generic, generic-hmac signature | Repo change, see Flux on talos |
gatus | Gatus on talos | ntfy, token tk_… | Repo change, see Gatus |
ci | Gitea Actions: a failure step in build-oci-apps and Renovate | generic, Bearer token | Gitea secret + repo change, see Gitea Actions |
proxmox | the Proxmox VE cluster, proxmox1–4 | gotify, app token | In the Proxmox UI, see Proxmox VE |
synology | DS723+ | generic, ?token= | In DSM, see Synology DSM |
sonarr, radarr, lidarr, whisparr, prowlarr | the *arr apps | generic, Basic auth password | In each app, see The *arr apps |
seerr | Seerr | generic, Authorization header | In Seerr, see Seerr |
cleanuparr | cleanuparr | ntfy, token | In cleanuparr, see cleanuparr |
scripts | stellwerk send or curl from runbooks such as talos-upgrade.sh | generic, Bearer token | Ready, 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.yamlEvery 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: trueEndpoints 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/cibuild-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:
- Datacenter → Notifications → Notification Targets → Add → Gotify: name
stellwerk, serverhttps://stellwerk.web.domain.tld/gotify, API token = theproxmoxtoken. - Notification Matchers → Add: target
stellwerk, matching severitywarninganderror, or everything if backup successes should land in Warnings too. - 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>, methodPOST, content typeapplication/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, …), methodPOST - 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
criticalgoes loud to Alarm with priority urgent, a resolvedcriticalfollows quietly into the same room, everything else goes to Warnings. The Watchdog never reaches a room: it is consumed as the heartbeatalertmanager-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-appsmeans 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
Depends on
stellwerk — Edge cluster
Deviations from defaults
- Hostname inside the passthrough wildcard —
stellwerk.web.domain.tldis covered by the*.web.domain.tldDNS record, so no record had to be added. Thepublic-kuebergateway gives it its own HTTPS listener (https-stellwerk-web-kueber-eu) next to theweb-tlspassthrough to the home cluster, the wayoci.web.domain.tlddoes for zot. Browsers that reuse a connection to another*.web.domain.tldsite land on the home gateway, which answers421for this name (k8s/platform/configs/talos/envoy-gateway/http-route-misdirected-oci.yaml); a split-horizon DNS for*.web.domain.tldmust leave this name alone, or talos would send its alerts to itself. - UI under
int.domain.tld, notedge.int.domain.tld—stellwerk.int.domain.tldis an A record in the NetBird zoneint.domain.tld(tofu/environment/netbird/dns.tf) pointing at the internal gateway’s LoadBalancer IP172.30.0.11, inside the edge subnet NetBird routes to administrators. The gateway’s*.edge.int.domain.tldwildcard does not cover the name, so it has its own listener (https-stellwerk-int-kueber-eu) and certificate. - No metrics —
metrics.listenis empty: edge runs no metrics stack to scrape them. Gatus on talos watches/readyzfrom outside and mails when it fails. - Flux events in-cluster — the
Providerposts to the Service, not to the public hostname, so a broken gateway on this cluster can still report itself. - Backups at 04:00 —
stellwerk-datagoes to the Hetzner bucketworkload-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