Skip to content

Deployment & operations

Concrete topologies, configs, and the operational runbook for running SIPhon in production. Read scaling-and-redundancy.md first for why these are the shapes — this doc is the how.

The golden rule from that document, restated: one node does the work; you add nodes for redundancy, and you get redundancy with a front LB + DNS SRV, not a cluster.

A runnable, self-contained version of Scenario 2 lives in deploy/ha-demo/; the Kubernetes manifests are in deploy/k8s/.


Scenario 1: single node

The default, and the right answer for most deployments. One process, optionally a Redis backend so a restart comes back whole.

# siphon.yaml
listen:
  udp: ["0.0.0.0:5060"]
  tcp: ["0.0.0.0:5060"]
domain:
  local: ["example.com"]
script:
  path: "scripts/proxy_default.py"

registrar:
  backend: redis            # durability: a restart reloads the full snapshot
  redis:
    url: "redis://127.0.0.1:6379"

server:
  instance_id: "${HOSTNAME}"
  drain_secs: 30            # graceful drain on SIGTERM (see runbook)

metrics:
  prometheus:
    listen: "0.0.0.0:9090"  # /metrics — Prometheus scrape

admin:
  listen: "0.0.0.0:9091"    # /admin/health + /admin/ready probes, registrations

That's a production-shaped single node. A "warm spare" is just a second box with the same config, kept ready; promote it by moving traffic (DNS/VIP) when you need to.


Scenario 2: redundant pair, N nodes

Survive a node failure and do zero-downtime upgrades. Three ingredients, none of which require the nodes to share live call state:

  1. DNS SRV so clients/upstreams fail new calls over automatically.
  2. A front-facing SIP load balancer spreading new transactions across backends.
  3. A shared Redis registrar backend so a restarted/replacement node is whole.

DNS SRV (the primary failover mechanism)

Publish every node as an SRV target. Equal priority + weight = load spread; lower priority = standby.

;; Active/active across two nodes
_sip._udp.example.com. 3600 IN SRV 10 50 5060 node1.example.com.
_sip._udp.example.com. 3600 IN SRV 10 50 5060 node2.example.com.

;; Or active/standby: node2 only used if node1 is unreachable
_sip._udp.example.com. 3600 IN SRV 10 100 5060 node1.example.com.
_sip._udp.example.com. 3600 IN SRV 20 100 5060 node2.example.com.

SIPhon resolves SRV/NAPTR natively for its own outbound routing (RFC 3263), so this works in both directions.

The front LB (SIPhon fronting SIPhon)

You can use any SIP-aware load balancer you already trust. The self-contained way — and what deploy/ha-demo/ demonstrates — is a thin SIPhon proxy whose only job is to spread traffic over a gateway group of backends:

# frontend siphon.yaml — the load balancer
listen:
  udp: ["0.0.0.0:5060"]
domain:
  local: ["example.com"]
script:
  path: "lb.py"
gateway:
  groups:
    - name: "backends"
      algorithm: hash       # consistent hash => subscriber affinity (see below)
      probe:
        enabled: true
        interval_secs: 5
        failure_threshold: 3
      destinations:
        - { uri: "sip:node1.example.com:5060", address: "10.0.0.1:5060" }
        - { uri: "sip:node2.example.com:5060", address: "10.0.0.2:5060" }
# lb.py — spread new requests over the backend group; keep dialogs sticky
from siphon import proxy, gateway, log

@proxy.on_request
def route(request):
    if request.in_dialog:
        if request.loose_route():
            request.relay()
        else:
            request.reply(404, "Not Here")
        return

    # Affinity: hash on the AoR so a subscriber's REGISTER and the terminating
    # calls to them land on the SAME backend (which is the node that then holds
    # their binding in its local registrar).
    destination = gateway.select("backends", key=str(request.to_uri))
    if not destination:
        request.reply(503, "Service Unavailable")
        return
    request.record_route()
    request.relay(destination.uri)

Why the affinity hash matters

Registrar lookups are node-local (see scaling-and-redundancy.md). A subscriber can only be reached for a terminating call on the node holding their binding. Hashing both the REGISTER and the terminating INVITE on the AoR sends both to the same backend, so terminating delivery always works — with no shared live state. If you don't need any-node terminating delivery (e.g. pure outbound trunk / PSTN breakout), drop the affinity and use algorithm: weighted.

Backends

Each backend is a Scenario-1 node pointed at the same Redis, with a distinct instance_id:

registrar:
  backend: redis
  redis:
    url: "redis://redis.internal:6379"
server:
  instance_id: "node1"     # node2, node3, ... — distinct per node
  drain_secs: 30

Optional: a VIP instead of (or with) the front LB

For a classic active/standby pair, put a virtual IP (keepalived/VRRP) in front. The standby boots with the registrar snapshot and converges as UEs re-REGISTER; new calls ride DNS SRV during the swing. This is simpler than the front-LB approach but gives you active/standby rather than active/active.


Scenario 3: IMS core

In IMS, SIPhon does not need to share location state at all, because the HSS is the location authority:

  • The I-CSCF does a Cx LIR to the HSS to find the subscriber's serving S-CSCF, then routes there. Terminating routing never depends on any single SIPhon node's local registrar.
  • S-CSCF instances persist registrar bindings and iFC profiles in Redis, so an S-CSCF restart doesn't trigger an HSS re-fetch storm.
  • P-CSCF is edge state (IPsec SAs, Path) and scales horizontally behind the Gm reference point.

So an IMS core scales to many nodes per role using exactly the mechanisms above plus the HSS — no clusterer/DMQ equivalent required. See the examples/ims_* configs for per-role starting points.


Operations runbook

Graceful drain & rolling upgrades

On SIGTERM/SIGINT, SIPhon stops accepting new INVITEs and waits up to server.drain_secs (default 30s) for in-flight transactions and B2BUA calls to finish before exiting. Set drain_secs: 0 to exit immediately.

At the deadline it then ends the calls that are still up, within server.teardown_secs (default 5s): a BYE on both legs carrying Reason: Q.850;cause=16 (normal clearing), the Ro CCR-TERMINATION, the Rf stop, the media release and the CDR. A call lasts minutes and a drain is seconds, so this is the normal path on any restart taken with traffic up, not the exceptional one — before it existed, every such restart cut its calls with nothing on the wire and left the far side holding a channel until someone hung it up. teardown_secs: 0 restores that behaviour if you want it.

server:
  drain_secs: 30
  teardown_secs: 5

Your container runtime's stop timeout must exceed drain_secs + teardown_secs, or its SIGKILL lands first and none of this happens. Docker's default is 10 s (docker stop -t, stop_grace_period: in compose); Kubernetes' terminationGracePeriodSeconds defaults to 30 s.

B2BUA calls only. A proxied call cannot be torn down and that is a property of proxying, not a gap here: a proxy keeps transaction state, not dialog state — no callee To-tag, no remote target, no route set, no CSeq — so there is nothing an in-dialog BYE could be built from. On a pure proxy node the drain reports no active calls at all and completes immediately while proxied calls are up.

A rolling upgrade is therefore:

  1. Remove the node from the LB / DNS rotation (or let the LB's health probe do it).
  2. SIGTERM the process; it drains in-flight work.
  3. Replace the binary / image; start it. With a Redis backend it reloads the full registrar snapshot on boot.
  4. Re-add to rotation. Repeat per node.

In Kubernetes, wire this to the pod lifecycle (below): a preStop hook plus a terminationGracePeriodSeconds ≥ drain_secs + teardown_secs lets the drain and the teardown complete before the kubelet sends SIGKILL.

Health checks & probes

Enable the admin API and point your probes at it:

admin:
  listen: "0.0.0.0:9091"   # serves /admin/health, /admin/ready, /admin/*, /metrics
  • Liveness: GET http://<node>:9091/admin/health → 200 for as long as the process is alive. It does not flip during drain — a liveness probe failing mid-drain would make the orchestrator kill the node before it finished draining.
  • Readiness: GET http://<node>:9091/admin/ready → 200 normally, 503 while draining (after SIGTERM) so a load balancer / Kubernetes pulls the node from rotation before it stops accepting new INVITEs. Also 503 with {"status": "not_ready", "reason": "cache '<name>': Redis backend unreachable"} while the Redis of a cache: entry marked required_for_readiness: true does not answer (see Cache backend health). No cache is marked by default, so a node is not affected unless its config says so.

TLS and protect_reads

The admin API can force-unregister AoRs and lift auto-bans, and what it returns is the registration list (number, contact address, expiry) and the live call list. Two settings make it safe to expose to a controller rather than only through a tunnel:

admin:
  listen: "0.0.0.0:9091"
  auth:
    token: "${ADMIN_TOKEN}"
    protect_reads: true
  tls:
    certificate: "/etc/siphon/admin.pem"
    private_key: "/etc/siphon/admin.key"
    # verify_client: true
    # client_ca: "/etc/siphon/controller-ca.pem"
  • tls: is the same block the SIP listeners take, hot reload included — a renewed certificate is served by the next handshake, so cert-manager and certbot need no restart. Without it the bearer token crosses the wire in the clear on every call. verify_client: true with a client_ca makes it mutual, which is the stronger answer for a controller than a bearer token on its own. An unreadable certificate or key fails the config load naming admin.tls, rather than producing a listener that binds and fails every handshake.
  • protect_reads: true is now usable with the dashboard. The UI shell is served unauthenticated and every byte of data stays behind the token, so the dashboard loads, prompts for the token and works. Before this, a node that wanted a UI had to run with reads unprotected, which left the registration and call lists readable to anything the admin ACL admitted with no token at all. /admin/logs, /admin/capture and /admin/search are always gated regardless, and are refused outright when no token is configured.

The admin port also serves /admin/stats, /admin/registrations[/{aor}] (inspect or force-unregister bindings), and /metrics. If you'd rather not enable it, a GET /metrics returning 200 is a serviceable liveness signal and a SIP OPTIONS ping to the SIP port works for readiness (the default proxy scripts answer local OPTIONS with 200).

Metrics and alerting

Scrape /metrics. The handful that matter operationally:

Signal Alert when Why
siphon_memory_allocated_bytes rate(...[30m]) > 0 while call rate is flat A real leak. The per-structure gauges (siphon_proxy_dialog_sessions, siphon_uac_pending_requests) localize it.
siphon_pyexec_jobs_shed_total sustained rate() > 0 Handler pool saturated + queue full → SIP retransmits. Raise sync_pool_max or speed up handlers.
siphon_timer_jobs_shed_total{timer} any increase() > 0 A @timer.every run was skipped because the pool was full, so whatever that timer maintains (a periodic count, a cleanup) is one interval stale. Logged as timer callback shed, not as a panic.
siphon_pyexec_pool_size vs _pool_max pool_size == pool_max and inflight == pool_size for minutes Pool fully grown and saturated, approaching the liveness watchdog.
siphon_proxy_dialog_sessions grows unbounded under flat completed-call load Dialog state not draining — a leak signature.
siphon_gateway_source_last_success_timestamp_seconds time() - <gauge> > 3 * refresh_secs, or the gauge is 0 The carriers this node routes over are stale — it kept the last set it read, correctly, and nothing else says the controller has been unreachable for hours. 0 means it has never been read, so a node that booted against a dead controller has no carriers from the source at all.
siphon_gateway_source_failures_total sustained rate() > 0 Reads are failing now. Pair with the timestamp above, which says for how long.
process_open_fds / process_max_fds > 0.8 Descriptors running out. Each TCP/TLS/WS client holds one. siphon raises its soft limit to the hard limit at startup, so the ceiling is whatever the container ulimits nofile or systemd LimitNOFILE hard limit says; a startup WARN names a limit below 65536.
siphon_accept_errors_total{reason="emfile"} any increase() > 0 A listener ran out of descriptors and is backing off its accepts (5 ms up to 1 s). New clients wait in the backlog until descriptors free up.
siphon_registrant_source_* same pair, same thresholds Outbound trunk registrations, tracked separately: a node can route over stale carriers with current registrations, or the reverse.
siphon_presence_subscriptions_removed_total{reason} rate() jumps with no matching drop in registrations Subscriptions the notifier dropped because their NOTIFY failed (RFC 6665 §4.2.2): notify_rejected for a 481 and the other codes §4.2.2 names, notify_timeout for no final response before Timer F or a 408. A burst after a subscriber-side restart is expected (those watchers re-SUBSCRIBE); a steady rate means NOTIFYs are being sent to dialogs the subscribers no longer hold, or not reaching them at all.
siphon_subscribe_notify_failures_total{code} sustained rate() > 0 for 481 or timeout NOTIFYs of proxy.subscribe_state subscriptions that ended without a 2xx, by final status or timeout (no final response before Timer F). A 481 and the other codes RFC 6665 §4.2.2 names, a 408 and a timeout also remove the subscription, so each such subscriber costs one failed NOTIFY and a burst after a subscriber-side restart dies out by itself. A steady timeout rate means NOTIFYs are not reaching subscribers (a route set or a transport problem); other codes (401, 503) keep the subscription and repeat on every state change until it expires.

The allocator exposes its own numbers alongside those, and they answer different questions — reading only one is how a fragmentation problem gets misfiled as a data-structure problem:

Gauge jemalloc stat What it is
siphon_memory_allocated_bytes stats.allocated Live bytes. What the data structures actually cost. The leak signal.
siphon_memory_active_bytes stats.active Bytes in pages holding live allocations.
siphon_memory_resident_bytes stats.resident Physical pages the allocator holds. Tracks RSS.
siphon_memory_retained_bytes stats.retained Virtual address space kept back rather than returned to the OS. Explains RSS above allocated.
siphon_memory_mapped_bytes stats.mapped Total mapping.
siphon_memory_metadata_bytes stats.metadata Allocator bookkeeping — arena headers, extents, bin metadata. Scales with arena count, not with traffic.

resident - allocated is the allocator's overhead, not yours. Diagnose a growing RSS by asking which of the two is moving before changing any code.

See handler-execution-model.md for the pool internals and the blocking-handler contract that drives these.

Capacity planning

  • Throughput: ~28–30k cps per node on commodity hardware (the README baseline); free-threaded CPython 3.14t is required to reach it (the container image ships it).
  • Memory: three separate terms, and they scale differently.
  • Handler pool — roughly sync_pool_max × ~2 MB at peak. Lower script.sync_pool_max on memory-constrained nodes; prefer auth.http.cache_ttl_secs so an auth storm never needs the pool to grow in the first place.
  • Registrar bindings — budget ~1.8 KB resident per binding (~0.85 KB of live data, the rest allocator page overhead). So 600k contacts is roughly 1 GB on top of the fixed cost. Measure it for your own contact shape with scripts/registrar_scale_test.sh, which registers a population of unique AoRs and reports marginal bytes per binding against an idle baseline from the same process.
  • Allocator metadata — jemalloc defaults to 4 × ncpus arenas, and each one costs bookkeeping. On a 24-core box that is ~30 MB of siphon_memory_metadata_bytes before a single call. See below.
  • Trimming the fixed cost on a small node. narenas is settable without rebuilding, via jemalloc's own environment variable (the _rjem_ prefix is tikv-jemallocator's symbol prefix, not a typo):
_RJEM_MALLOC_CONF=narenas:4 siphon -c siphon.yaml

Measured on a 24-core box, 200k bindings, narenas:4 against the default 96 arenas: idle RSS 89 MB → 78 MB and allocator metadata 30 MB → 8.6 MB, with the marginal cost per binding unchanged (1790 vs 1787 bytes resident). So this is a fixed-cost lever, worth taking on a container with a small limit and close to irrelevant at large contact counts, where the per-binding term dominates. It is not the default because fewer arenas means more threads per arena lock, and SIPhon's throughput ceiling has not been re-validated under it — if you set it on a node that matters, re-run your own throughput row first. A binary that embeds SIPhon as a library can bake the same string in via siphon::install_allocator!("narenas:4,background_thread:true,dirty_decay_ms:1000,muzzy_decay_ms:0"). - File descriptors: one per TCP, TLS or WebSocket client, plus a few hundred for siphon itself. siphon raises its soft RLIMIT_NOFILE to the hard limit at startup (logged as RLIMIT_NOFILE soft 1024 -> 524288 (hard 524288)), so set the hard limit to what the node should hold: ulimits: nofile: in compose, LimitNOFILE= in a systemd unit. Docker and systemd already default the hard limit to 524288. - Stability over heroics: if a node is unstable under load, fix the instability — don't paper over it with more nodes. The liveness watchdogs (script.handler_stall_abort_secs for the handler pool, script.process_stall_abort_secs for the whole process) convert a hang into a fast supervised restart rather than an indefinite outage.

State backup & DR

The only durable state SIPhon owns lives in your Redis / PostgreSQL registrar backend (bindings, service-routes, P-Associated-URIs, iFC profiles). Back that up with its native tooling (Redis RDB/AOF, pg_dump). Everything else is either ephemeral (transactions, dialogs — not meaningful to back up) or reconstructed from re-registration. There is no SIPhon-specific snapshot format to manage.


Kubernetes (kept deliberately light)

People expect to see K8s, so here's a clean shape to copy — not a platform. Manifests are in deploy/k8s/. The load-bearing details:

  • StatefulSet (not Deployment) so each pod has a stable identity. Wire server.instance_id from the pod name via the downward API:
env:
  - name: POD_NAME
    valueFrom: { fieldRef: { fieldPath: metadata.name } }
# siphon.yaml: server.instance_id: "${POD_NAME}"
  • Graceful drain: let the SIGTERM drain finish before SIGKILL.
terminationGracePeriodSeconds: 40        # >= server.drain_secs
# (SIGTERM is sent on pod termination; siphon drains for drain_secs.)
  • Probes on the admin API (admin.listen) — liveness that survives drain, readiness that fails closed during drain:
livenessProbe:
  httpGet: { path: /admin/health, port: 9091 }
  initialDelaySeconds: 5
  periodSeconds: 10
readinessProbe:
  httpGet: { path: /admin/ready, port: 9091 }   # 503 while draining
  periodSeconds: 5
  • Networking: SIP is sensitive to NAT rewriting of Via/Contact, and to losing the client's source address. Which fix applies depends on whether your ingress forwards packets or terminates the connection:
    • Forwarding ingress (a plain L4 LoadBalancer, DSR): preserve the client source with hostNetwork: true or a properly configured externalTrafficPolicy: Local. There is no header to read, so this is the only thing that works — and it is enough.
    • Terminating ingress (an L7 or TLS-terminating front, an Ingress controller, anything that re-encrypts): it opens its own connection, so source preservation is not available to it by definition. Have the front send a PROXY header and set proxy_protocol.from on the matching stream listener — see Transports.

Either way, set advertised_address to what peers should see. - Redis as a normal dependency (a Deployment + Service, or a managed Redis). All siphon pods share it for registrar durability. - Config via a ConfigMap (siphon.yaml + the script), mounted read-only.

That's enough to run a redundant SIPhon StatefulSet behind a Service. Scale with replicas; pair it with subscriber-affinity at your ingress if you need any-pod terminating delivery. Anything fancier (HPA on cps, per-pod SRV, Diameter SCTP) is a deployment-specific exercise, not something to bake into a starter manifest.

Cache backend health

Each cache: entry keeps one connection to its Redis and probes it with PING once a second, used or not. When the server goes away (restart, failover, network), the connection is redialled; nothing has to be restarted.

  • While it is unreachable, cache calls fail at once instead of each waiting on a connect: cache.fetch returns None, cache.store / cache.delete return False. Each is counted in siphon_cache_errors_total{cache,op}, the gauge siphon_cache_backend_up{cache} reads 0, and the outage is logged once at error, the recovery once at info.
  • Readiness does not follow it unless you say so. By default a cache whose Redis is down leaves /admin/ready at 200: the gauge and the error counter are the signal, and the node keeps serving whatever does not need the cache.
  • Mark a cache the node cannot serve without with required_for_readiness: true (routing state a script reads, where a fetch returning None for a key that exists means a wrong answer). /admin/ready then answers 503 naming the cache, from process start until its Redis first answers and again whenever it is unreachable, so an orchestrator stops sending the node traffic. With one Redis shared by every node, a required cache takes all of them out of rotation together when that Redis is down; decide per cache whether a node without it is better than no node. /admin/health never changes: restarting the process would not bring Redis back.
  • A command caught by a dropped connection is sent again once on the new connection when that is safe: fetch, store, delete, exists, expire, list_len, list_len_sum. list_push and list_pop_all are not repeated (a repeat could queue an item twice, or drop the items the first attempt already removed): they report failure once and the next call works.
cache:
  - name: flows            # routing state: no Redis, not ready
    url: "redis://redis.example.com:6379"
    required_for_readiness: true
  - name: cnam             # optional lookup: keep serving without it (default)
    url: "redis://redis.example.com:6379"

Redis / Valkey Sentinel

Registrar persistence and named caches accept either the existing url or a sentinel block. Do not specify both. iFC profiles and presence subscriptions use the registrar's target automatically.

registrar:
  backend: redis
  redis:
    sentinel:
      addresses: ["localhost:26379", "localhost:26380", "localhost:26381"]
      master: primary
      password: "${REDIS_PASSWORD}"
      sentinel_password: "${SENTINEL_PASSWORD}"
      db: 0
    key_prefix: "siphon:reg:"

cache:
  - name: routing
    sentinel:
      addresses: ["localhost:26379", "localhost:26380", "localhost:26381"]
      master: primary
      db: 1

addresses and master are required. password authenticates to the data nodes; sentinel_password authenticates to the sentinels. Both passwords are optional. db defaults to zero. Environment variables expand as in the rest of the YAML configuration. Existing url: redis://localhost:6379/0 entries need no changes.

The same target fits in a URL, wherever siphon takes one (url: of the registrar and of a cache, a shard in urls): redis+sentinel://[:password@]host[:port][,host[:port]...]/master[/db][?sentinel_password=...]. The port defaults to 26379 and the credentials are percent-decoded. A configuration that writes its URL from the environment, such as url: "${CACHE_URL:-redis://192.0.2.10:6379}", then moves between one Redis and a Sentinel set without changing shape.

For a sharded registrar, set shard_count and list that many targets under urls. Legacy URL strings remain accepted; mapping entries use the same shared target shape:

registrar:
  backend: redis
  redis:
    shard_count: 2
    urls:
      - "redis://localhost:6379/0"
      - sentinel:
          addresses: ["localhost:26379", "localhost:26380", "localhost:26381"]
          master: second-primary

Without a separate top-level target, iFC and presence use the first shard. On a connection error, READONLY, or MASTERDOWN, the async connection rediscovers the primary and retries the operation once. Discovery/connection has a two-second deadline, commands have a 500 ms response timeout, and reconnect attempts have a 100 ms backoff. Each Sentinel endpoint gets up to 500 ms, within the discovery deadline. An operation including time queued behind another reconnect is bounded to five seconds. A failed retry returns an error and logs the failure; persistence writers retain pending state under their existing retry policy. A write whose response was lost may already have executed: non-idempotent commands and pipelines can be replayed, so this is not an exactly-once guarantee. Reads that succeed on an old replica do not trigger rediscovery.

Cache store and delete return false when the Redis write fails, even if the local LRU was updated; they no longer report a failed write as successful.

Redis / Valkey over TLS

A rediss:// URL connects over TLS (rustls) and verifies the server certificate: its chain and its name, against the host in the URL. A certificate whose subjectAltName is an IP address verifies when the URL names that address. There is no setting that turns verification off.

Without anything else the certificate must chain to the public web roots built into the binary (the Mozilla set), not to the host's trust store. A managed Redis or Valkey usually signs with a private CA; give that CA as a PEM bundle in tls.ca_file, beside url, and the server is verified against it alone:

registrar:
  backend: redis
  redis:
    url: "rediss://:${REDIS_PASSWORD}@192.0.2.10:6380/0"
    tls:
      ca_file: /etc/siphon/redis-ca.pem

cache:
  - name: routing
    url: "rediss://valkey.example.net:6380/1"
    tls:
      ca_file: /etc/siphon/redis-ca.pem

The URL carries the same setting as a ca_file parameter, so a target written from the environment needs no other key, and a shard in urls takes it too:

cache:
  - name: routing
    url: "${CACHE_URL:-redis://192.0.2.10:6379}"
# CACHE_URL=rediss://192.0.2.10:6380/1?ca_file=/etc/siphon/redis-ca.pem

Percent-encode a path that holds anything but letters, digits and / - . _ ~. Give the CA in one place, tls.ca_file or the URL, not both.

A Sentinel set uses TLS when tls: stands beside sentinel: (an empty tls: {} verifies against the public roots), or when its URL starts with rediss+sentinel://, which takes the same ca_file parameter. TLS then covers the connections to the sentinels and to the data nodes, all verified against the one CA. Sentinels report data nodes by IP address unless they are set to announce hostnames, so the data nodes' certificates need those addresses as subjectAltNames.

registrar:
  backend: redis
  redis:
    sentinel:
      addresses: ["192.0.2.10:26379", "192.0.2.11:26379", "192.0.2.12:26379"]
      master: primary
    tls:
      ca_file: /etc/siphon/redis-ca.pem
# or: url: "rediss+sentinel://192.0.2.10,192.0.2.11,192.0.2.12/primary?ca_file=/etc/siphon/redis-ca.pem"

The file is read and checked when the configuration loads: a ca_file that is missing, holds no certificate or holds one that is not a usable CA stops the start with an error, as does tls: or ca_file on a redis:// or redis+sentinel:// target. It is read again at each reconnect, so a replaced bundle is picked up without a restart; if it has become unreadable the reconnect fails and says so, it does not fall back to the public roots.