gatus: deploy on prd-monitoring, behind Caddy basic auth

First step of replacing Uptime Kuma and ntfy. Gatus runs on the new
observability VPS, fronted by Caddy at status.contrapeso.xyz.

Deployed as the upstream container image, not built from source. The role did
build from source first - their Dockerfile is a bare `CGO_ENABLED=0 go build`,
the Vue dashboard is compiled in via `//go:embed static` in web/static.go, and
CGO can stay off because the sqlite driver is pure-Go modernc.org/sqlite - but
that produces a binary upstream never ran, and it meant compiling the AWS SDK
and gRPC on the smallest box in the estate. That load was heavy enough that
unrelated Ansible tasks timed out while it ran. The cost of the container is a
daemon on the machine whose job is to notice when everything else breaks; that
trade is made deliberately and is written down in the role README.

Pinned by DIGEST, not tag. A tag is mutable - v5.36.0 can be repushed - so
pinning it alone is a weaker promise than it looks:

    gatus_image: "ghcr.io/twin/gatus@sha256:c5f210d0..."

`docker compose pull` now either fetches exactly the reviewed image or fails.
gatus_version is kept beside it only so a human can read the release; the two
move together.

The image is FROM scratch, so it has no /etc/passwd and its default user is
root. The container runs as 10001:10001 with the host data dir owned to match,
plus read_only, cap_drop ALL, and no-new-privileges. NET_RAW is added back only
when gatus_allow_icmp, so the capability for icmp:// checks is a visible grant
rather than something inherited from running as root.

Config is a DIRECTORY, not a file. Gatus merges every *.yaml under
GATUS_CONFIG_PATH - maps deep-merge, lists append - so the role owns
00-base.yaml (web, storage, ui, alerting, security) and each service will drop
its own file into endpoints/, the same shape as caddy_site. A primitive defined
twice is ambiguous and upstream refuses it, so anything that is not a list lives
in the base file and nowhere else.

Two bugs the deploy caught:

  * Gatus panics on a config with no endpoints ("configuration should contain at
    least one endpoint or suite"), so "install now, add endpoints later" is not
    a valid state. The role ships endpoints/00-self.yaml checking its own
    /health. Less circular than it looks: it proves the directory merged, the
    listener serves, and storage accepted a write.

  * web.address was carried over from the systemd design as 127.0.0.1. Inside a
    container that is the CONTAINER's loopback, which docker-proxy cannot reach
    - gatus came up healthy, self-check passing, while every connection to the
    published port was refused. It now always binds 0.0.0.0 inside the
    container; the isolation comes from publishing to 127.0.0.1 on the host.

Auth is done at the edge, NOT with Gatus's own security.basic. Reading
api/api.go, that middleware protects exactly four routes - the statuses
endpoints. Everything else is registered on the unprotected router, including
/api/v1/config, every badge, and /api/v1/endpoints/:key/uptimes/:duration and
.../response-times/:duration/history, which return real data to anyone who can
guess a key ("<group>_<name>"). Verified against the live instance: all seven
routes returned 200 unauthenticated, and /uptimes/24h returned "1.000000".

So the vhost uses caddy_site_body with a path carve-out rather than
caddy_site_basic_auth, which has no way to exempt a path. The external-endpoint
push API must NOT sit behind basic auth: it authenticates with
`Authorization: Bearer <token>`, and basic auth wants the same header. It is not
unauthenticated - the handler 401s on a missing prefix, an empty token, or a
token that does not match that endpoint's own.

Verified end to end. All seven previously-open routes now 401. The push path
distinguishes cleanly: POST with no auth gets Gatus's own "invalid Authorization
header" with NO WWW-Authenticate; POST with a bogus Bearer gets 404 (key looked
up, no external endpoints yet); GET on the same path gets Caddy's 401 with
WWW-Authenticate: Basic, so the exemption is scoped to POST alone. The
self-check still passes because it polls localhost inside the container and
never traverses Caddy.

The host itself was rebuilt from scratch: 01 (ok=9 changed=8), 02 (ok=12
changed=6), 910_docker (--limit, since that playbook still wrongly claims all of
`managed` needs Docker), caddy (ok=13 changed=8), gatus (ok=18 changed=2).

Not done here: gatus_alerting is still {} - valid, and every condition is
evaluated and recorded, there is just nowhere to shout until a provider is
chosen to replace ntfy.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

ansible/roles/gatus/README.md

@@ -0,0 +1,110 @@
+# gatus
+
+Deploys [Gatus](https://github.com/TwiN/gatus) — health checks, a status page,
+and alerting — **as the upstream container image**, on the
+`observability` group.
+
+## Why the container
+
+Upstream publishes **no binary release assets**. The image is the only artefact
+they ship and therefore the only one they test, so it is what `docker run` in
+their README gets you, and it is what this role deploys.
+
+Building from source is entirely possible — their Dockerfile is a bare
+`CGO_ENABLED=0 go build`, the Vue dashboard is compiled in via `//go:embed
+static` in `web/static.go`, and the sqlite driver is pure-Go
+`modernc.org/sqlite` so nothing needs linking. This role did that at first. The
+reasons it doesn't now:
+
+- It produces a binary upstream never ran.
+- It means compiling the AWS SDK, gRPC and the Google API libraries on the
+  smallest box in the estate. On this VPS that load was heavy enough that
+  unrelated Ansible tasks timed out while it ran.
+
+The cost of the container is a daemon on the machine whose job is to notice
+when everything else breaks. That is a real trade, made deliberately.
+
+## Pinned by digest, not by tag
+
+```yaml
+gatus_image_digest: "sha256:c5f210d0…"
+gatus_image: "ghcr.io/twin/gatus@{{ gatus_image_digest }}"
+```
+
+A tag is mutable — `v5.36.0` can be repushed — so pinning the tag alone is a
+weaker promise than it looks. The digest is a content address: if it resolves,
+it is byte-for-byte the image reviewed here, and `docker compose pull` either
+fetches exactly that or fails. `gatus_version` is kept alongside it purely so a
+human can read which release it is; **the two must be updated together.**
+
+## What `FROM scratch` means for running it
+
+The image has no `/etc/passwd`, so there is no user to drop to by name and the
+default is root. The compose file runs it by numeric id (`10001:10001`) and the
+data directory on the host is owned to match. Everything else is locked down to
+approximate what the systemd unit used to do natively:
+
+| systemd | compose |
+|---|---|
+| `ProtectSystem=strict` | `read_only: true` |
+| `NoNewPrivileges=true` | `security_opt: [no-new-privileges:true]` |
+| `CapabilityBoundingSet=` | `cap_drop: [ALL]` |
+| `AmbientCapabilities=CAP_NET_RAW` | `cap_add: [NET_RAW]` (for `icmp://`) |
+
+## Configuration is a directory, not a file
+
+`GATUS_CONFIG_PATH` points at `/opt/gatus/config`, and Gatus merges every `*.yaml`
+underneath it — maps deep-merge, lists append. This role owns exactly one file:
+
+```
+/opt/gatus/config/00-base.yaml      web, storage, ui, alerting, security   (this role)
+/opt/gatus/config/endpoints/*.yaml  one file per service                   (gatus_endpoint)
+```
+
+**A primitive defined in two files is ambiguous and upstream refuses it.** So
+anything that is not a list belongs in `00-base.yaml` and nowhere else. Endpoints
+are lists, so each service's file appends cleanly — the same shape as
+`caddy_site`, where each service contributes its own vhost.
+
+## Pull and push
+
+Gatus polls. For anything with a reachable HTTP or TCP surface that is the
+better check, because it tests the path a user actually takes. The monitoring
+host joins the headscale mesh via `infra/920`, so internal boxes are reachable
+by MagicDNS name and can be polled directly rather than having to report in.
+
+For state with no pollable surface — ZFS pool health, UPS mains status, disk
+usage, backup freshness — Gatus has **external endpoints**, a push API:
+
+```
+POST /api/v1/endpoints/{group}_{name}/external?success=true&error=&duration=
+Authorization: Bearer <token>
+```
+
+with `heartbeat.interval` to alert when nothing reports in. That is the same
+shape as the generic `healthcheck_push_url` already wired into every service
+role, so those scripts need a URL, a POST, and an auth header — not a rewrite.
+
+## Variables
+
+See `defaults/main.yml`. The ones that matter:
+
+| Variable | Default | Note |
+|---|---|---|
+| `gatus_version` / `gatus_image_digest` | `v5.36.0` / `sha256:c5f210d0…` | must move together |
+| `gatus_bind_address` | `127.0.0.1` | **never bind publicly** — the push API shares this listener |
+| `gatus_storage_type` | `sqlite` | `memory` loses all history on restart |
+| `gatus_alerting` | `{}` | pass-through; any provider Gatus supports |
+| `gatus_allow_icmp` | `true` | adds back `NET_RAW` for `icmp://` checks |
+
+`gatus_alerting` empty is valid and is the current state: every condition is
+still evaluated and recorded, there is just nowhere to shout yet.
+
+## Verifying
+
+```bash
+docker ps --filter name=gatus
+docker logs gatus --tail 50
+curl -s localhost:8080/health
+ls /opt/gatus/config/endpoints/
+```

ansible/roles/gatus/defaults/main.yml

@@ -0,0 +1,83 @@
+---
+# Gatus, deployed the way upstream distributes it: the container image.
+#
+# Upstream publishes NO binary release assets - the image is the only artefact
+# they ship, and therefore the only artefact they test. Building from source is
+# possible (`go build` alone is enough; the Vue dashboard is compiled in via
+# `//go:embed static`, and CGO_ENABLED=0 works because the sqlite driver is
+# pure-Go modernc.org/sqlite) but it produces a binary upstream never ran, and
+# it means a full compile of the AWS SDK and gRPC on the smallest box in the
+# estate.
+
+# ── Image ────────────────────────────────────────────────────────────────────
+gatus_version: "v5.36.0"
+# Pinned by DIGEST, not by tag. A tag is mutable - `v5.36.0` can be repushed -
+# so pinning the tag alone is a weaker promise than it looks. The digest is the
+# content address: if it resolves, it is byte-for-byte the image reviewed here.
+# Both must be updated together; the tag is kept only so humans can read it.
+gatus_image_digest: "sha256:c5f210d095fa78e6efaa20ffeb14803f2ba4f10615e16a6d12087697149617f0"
+gatus_image: "ghcr.io/twin/gatus@{{ gatus_image_digest }}"
+
+# ── Paths (host side) ────────────────────────────────────────────────────────
+gatus_dir: /opt/gatus
+gatus_config_dir: "{{ gatus_dir }}/config"
+gatus_data_dir: "{{ gatus_dir }}/data"
+
+# Gatus merges every *.yaml under GATUS_CONFIG_PATH and its subdirectories:
+# maps deep-merge, lists append. That is why this role ships a config DIRECTORY
+# rather than one file - each service contributes its own endpoint file, the
+# same way each service contributes a vhost through `caddy_site`.
+#
+# Primitives must be defined exactly once across all files or the merge is
+# ambiguous, so everything that is not a list lives in the base file and
+# nowhere else.
+gatus_base_config_file: "00-base.yaml"
+gatus_endpoints_dir: "{{ gatus_config_dir }}/endpoints"
+
+# ── Identity ─────────────────────────────────────────────────────────────────
+# The image is FROM scratch, so it has no /etc/passwd and no user to drop to by
+# name. Run it by numeric uid/gid instead, and own the data volume to match.
+gatus_uid: 10001
+gatus_gid: 10001
+
+# ── Web ──────────────────────────────────────────────────────────────────────
+gatus_port: 8080
+# HOST-side address the container's port is published on. Gatus itself always
+# binds 0.0.0.0 inside the container - see the note in config.yaml.j2. Never
+# publish this on 0.0.0.0: the external-endpoint push API shares the dashboard's
+# listener, and Caddy is what should be in front of both.
+gatus_bind_address: "127.0.0.1"
+gatus_ui_title: "Status"
+gatus_ui_header: "Status"
+
+# ── Storage ──────────────────────────────────────────────────────────────────
+# sqlite, not memory: history has to survive a restart, or the dashboard lies
+# about uptime after every deploy. Path is INSIDE the container.
+gatus_storage_type: sqlite
+gatus_storage_path: "/data/gatus.db"
+gatus_storage_caching: true
+
+# ── Alerting ─────────────────────────────────────────────────────────────────
+# Pass-through: rendered verbatim under `alerting:`, so any provider Gatus
+# supports works without touching this role. Empty means "check and record,
+# alert nowhere" - valid, and the default until a provider is chosen.
+gatus_alerting: {}
+gatus_default_alerts: []
+
+# ── Security ─────────────────────────────────────────────────────────────────
+#   gatus_basic_auth: {username: admin, password-bcrypt-base64: "..."}
+gatus_basic_auth: {}
+
+gatus_maintenance: {}
+gatus_log_level: INFO
+
+# ── Self-check ───────────────────────────────────────────────────────────────
+# Gatus panics on a config with no endpoints, so the role always ships one.
+# Turning this off is only safe once another file in endpoints/ provides one.
+gatus_self_check: true
+
+# ── ICMP ─────────────────────────────────────────────────────────────────────
+# Gatus supports icmp:// endpoints. Raw ICMP needs CAP_NET_RAW, which the
+# container would get free only if it ran as root; it does not. Set false if
+# you never use icmp:// checks and want the capability dropped entirely.
+gatus_allow_icmp: true

ansible/roles/gatus/handlers/main.yml

@@ -0,0 +1,5 @@
+---
+- name: Restart gatus
+  ansible.builtin.command:
+    cmd: docker compose up -d --force-recreate
+    chdir: "{{ gatus_dir }}"

ansible/roles/gatus/tasks/configure.yml

@@ -0,0 +1,54 @@
+---
+- name: Assert Docker is available
+  ansible.builtin.command: docker --version
+  register: gatus_docker_check
+  changed_when: false
+  failed_when: gatus_docker_check.rc != 0
+
+- name: Create the gatus directories
+  ansible.builtin.file:
+    path: "{{ item.path }}"
+    state: directory
+    owner: "{{ item.owner }}"
+    group: "{{ item.group }}"
+    mode: "{{ item.mode }}"
+  loop:
+    - {path: "{{ gatus_dir }}",           owner: root,             group: root,             mode: "0755"}
+    # Config is root-owned and world-unreadable: it holds external-endpoint
+    # tokens. The container mounts it read-only and reads it as gatus_uid, so
+    # that id needs group access - hence the group ownership below.
+    - {path: "{{ gatus_config_dir }}",    owner: root,             group: "{{ gatus_gid }}", mode: "0750"}
+    - {path: "{{ gatus_endpoints_dir }}", owner: root,             group: "{{ gatus_gid }}", mode: "0750"}
+    # Data is the one path the container writes to, so it must be owned by the
+    # numeric id the container runs as. `read_only: true` makes everything else
+    # in the container immutable.
+    - {path: "{{ gatus_data_dir }}",      owner: "{{ gatus_uid }}", group: "{{ gatus_gid }}", mode: "0750"}
+
+- name: Write the base gatus configuration
+  ansible.builtin.template:
+    src: config.yaml.j2
+    dest: "{{ gatus_config_dir }}/{{ gatus_base_config_file }}"
+    owner: root
+    group: "{{ gatus_gid }}"
+    mode: "0640"
+  notify: Restart gatus
+
+# Without this the container crash-loops on an empty config. See the template.
+- name: Write the gatus self-check endpoint
+  ansible.builtin.template:
+    src: endpoint-self.yaml.j2
+    dest: "{{ gatus_endpoints_dir }}/00-self.yaml"
+    owner: root
+    group: "{{ gatus_gid }}"
+    mode: "0640"
+  when: gatus_self_check | bool
+  notify: Restart gatus
+
+- name: Write the docker compose file
+  ansible.builtin.template:
+    src: docker-compose.yml.j2
+    dest: "{{ gatus_dir }}/docker-compose.yml"
+    owner: root
+    group: root
+    mode: "0644"
+  notify: Restart gatus

ansible/roles/gatus/tasks/main.yml

@@ -0,0 +1,5 @@
+---
+# import, never include: dynamic includes are opaque to --list-tasks, which is
+# the primary verification tool in this repo.
+- ansible.builtin.import_tasks: configure.yml
+- ansible.builtin.import_tasks: service.yml

ansible/roles/gatus/tasks/service.yml

@@ -0,0 +1,35 @@
+---
+# Pulling by digest means this either fetches exactly the reviewed image or
+# fails. There is no "latest wins" path.
+- name: Pull the pinned gatus image
+  ansible.builtin.command:
+    cmd: docker compose pull
+    chdir: "{{ gatus_dir }}"
+  register: gatus_pull
+  changed_when: "'Downloaded newer image' in gatus_pull.stderr or 'Pull complete' in gatus_pull.stderr"
+
+- name: Start gatus
+  ansible.builtin.command:
+    cmd: docker compose up -d --remove-orphans
+    chdir: "{{ gatus_dir }}"
+  register: gatus_up
+  changed_when: "'Started' in gatus_up.stderr or 'Created' in gatus_up.stderr or 'Recreated' in gatus_up.stderr"
+
+- name: Flush handlers so a config change is live before it is verified
+  ansible.builtin.meta: flush_handlers
+
+- name: Wait for gatus to answer
+  ansible.builtin.uri:
+    url: "http://{{ gatus_bind_address }}:{{ gatus_port }}/health"
+    status_code: [200, 404]
+  register: gatus_health
+  until: gatus_health.status in [200, 404]
+  retries: 12
+  delay: 5
+
+- name: Assert gatus is running
+  ansible.builtin.assert:
+    that:
+      - gatus_health.status in [200, 404]
+    fail_msg: "gatus did not come up on {{ gatus_bind_address }}:{{ gatus_port }} - check `docker logs gatus`"
+    success_msg: "gatus is answering on {{ gatus_bind_address }}:{{ gatus_port }}"

ansible/roles/gatus/templates/config.yaml.j2

@@ -0,0 +1,56 @@
+# {{ gatus_base_config_file }} — managed by Ansible (roles/gatus)
+#
+# BASE CONFIGURATION ONLY.
+#
+# Gatus merges every *.yaml under GATUS_CONFIG_PATH: maps are deep-merged and
+# lists are appended, but a primitive defined in two files is ambiguous and
+# upstream refuses it. So `web`, `storage`, `ui`, `alerting` and `security` are
+# set here and MUST NOT appear in any other file in this directory.
+#
+# Endpoints are lists, so they append cleanly. Each service drops its own file
+# into endpoints/ via the gatus_endpoint role - the same shape as caddy_site.
+
+web:
+  # 0.0.0.0 is the CONTAINER's interface, not the host's. This must not be
+  # 127.0.0.1: that is the container's own loopback, which docker-proxy cannot
+  # reach, and gatus comes up healthy while the published port refuses every
+  # connection.
+  #
+  # The isolation comes from the port mapping in docker-compose.yml, which
+  # publishes to {{ gatus_bind_address }} on the host. Caddy fronts that, and it
+  # matters because the external-endpoint push API shares this listener with the
+  # dashboard.
+  address: 0.0.0.0
+  port: {{ gatus_port }}
+
+storage:
+  type: {{ gatus_storage_type }}
+{% if gatus_storage_type != 'memory' %}
+  path: {{ gatus_storage_path }}
+{% endif %}
+  caching: {{ gatus_storage_caching | bool | lower }}
+
+ui:
+  title: {{ gatus_ui_title }}
+  header: {{ gatus_ui_header }}
+{% if gatus_alerting %}
+
+alerting:
+{{ gatus_alerting | to_nice_yaml(indent=2) | indent(2, true) }}
+{% else %}
+
+# No alerting provider is configured yet. Gatus still evaluates every condition
+# and records every result; it simply has nowhere to shout. Setting
+# `gatus_alerting` is the single change needed to wire one up.
+{% endif %}
+{% if gatus_basic_auth %}
+
+security:
+  basic:
+{{ gatus_basic_auth | to_nice_yaml(indent=2) | indent(4, true) }}
+{% endif %}
+{% if gatus_maintenance %}
+
+maintenance:
+{{ gatus_maintenance | to_nice_yaml(indent=2) | indent(2, true) }}
+{% endif %}

ansible/roles/gatus/templates/docker-compose.yml.j2

@@ -0,0 +1,44 @@
+# Managed by Ansible (roles/gatus)
+services:
+  gatus:
+    image: {{ gatus_image }}
+    container_name: gatus
+    restart: unless-stopped
+
+    # The image is FROM scratch: no /etc/passwd, so there is no user to drop to
+    # by name and the default is root. Run it by numeric id instead.
+    user: "{{ gatus_uid }}:{{ gatus_gid }}"
+
+    ports:
+      # Loopback on purpose. Caddy fronts this, and the external-endpoint push
+      # API is served from the same listener as the dashboard - publishing
+      # 0.0.0.0 would put both straight on the public internet.
+      - "{{ gatus_bind_address }}:{{ gatus_port }}:{{ gatus_port }}"
+
+    environment:
+      GATUS_CONFIG_PATH: /config
+      GATUS_LOG_LEVEL: "{{ gatus_log_level }}"
+
+    volumes:
+      - {{ gatus_config_dir }}:/config:ro
+      - {{ gatus_data_dir }}:/data
+
+    # Hardening. The systemd unit this replaced got most of it from
+    # ProtectSystem/NoNewPrivileges/etc; these are the container equivalents.
+    read_only: true
+    security_opt:
+      - no-new-privileges:true
+    cap_drop:
+      - ALL
+{% if gatus_allow_icmp %}
+    cap_add:
+      # icmp:// endpoints need raw sockets. Dropped above with ALL, added back
+      # explicitly so the grant is visible rather than inherited from root.
+      - NET_RAW
+{% endif %}
+
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "3"

ansible/roles/gatus/templates/endpoint-self.yaml.j2

@@ -0,0 +1,25 @@
+# 00-self.yaml — managed by Ansible (roles/gatus)
+#
+# Gatus refuses to start with no endpoints at all:
+#   panic: error parsing config: configuration should contain at least one
+#   endpoint or suite
+#
+# So the role ships one. Checking its own listener is not as circular as it
+# looks: it proves the config directory parsed, the container is serving, and
+# the storage backend accepted a write. If this row is missing from the
+# dashboard, the dashboard is not telling you the truth about anything else.
+#
+# It is also what keeps `gatus` deployable before any service has contributed
+# an endpoint file of its own.
+
+endpoints:
+  - name: gatus
+    group: infrastructure
+    url: "http://localhost:{{ gatus_port }}/health"
+    interval: 60s
+    conditions:
+      - "[STATUS] == 200"
+{% if gatus_default_alerts %}
+    alerts:
+{{ gatus_default_alerts | to_nice_yaml(indent=2) | indent(6, true) }}
+{% endif %}