The reconciler service under the reconcile profile runs the API image with the reconciler module as entrypoint and --dry-run as the default command, so docker compose run --rm --no-deps reconciler takes only flags. It gets the database URL and the limited API key of S3, which already allows listing, reading and deleting objects, a read-only root, 1 CPU and 256 MiB, and a longer S3 read timeout for listing pages. S3, PostgreSQL and the reconciler accept an optional cpuset from the environment so measurements can pin them; the default is no pinning. make reconcile ARGS=... runs a pass, make reconcile-demo and make reconcile-cost drive the track experiments, and the limits policy now covers the new service. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
165 lines
6.4 KiB
Python
165 lines
6.4 KiB
Python
#!/usr/bin/env python3
|
|
import argparse
|
|
import json
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
S3_CLIENT_SECRETS = ["s3_access_key_id", "s3_root_password", "s3_root_user", "s3_secret_access_key"]
|
|
POLICY = {
|
|
"lb": {"secrets": [], "volumes": [], "networks": ["backend", "edge"], "ports": True},
|
|
"api": {
|
|
"secrets": [
|
|
"cache_url",
|
|
"cursor_secret",
|
|
"database_url",
|
|
"s3_access_key_id",
|
|
"s3_secret_access_key",
|
|
],
|
|
"volumes": [],
|
|
"networks": ["backend"],
|
|
},
|
|
"migrate": {"secrets": ["database_url"], "volumes": [], "networks": ["backend"]},
|
|
"reconciler": {
|
|
"secrets": ["database_url", "s3_access_key_id", "s3_secret_access_key"],
|
|
"volumes": [],
|
|
"networks": ["backend"],
|
|
},
|
|
"postgres": {"secrets": ["postgres_password"], "volumes": ["pgdata"], "networks": ["backend"]},
|
|
"valkey": {"secrets": ["valkey.conf"], "volumes": ["valkeydata"], "networks": ["backend"]},
|
|
"k6": {"secrets": [], "volumes": [], "networks": ["edge"]},
|
|
"s3": {
|
|
"secrets": ["s3_root_password", "s3_root_user"],
|
|
"volumes": ["s3data"],
|
|
"networks": ["backend"],
|
|
},
|
|
"s3-init": {"secrets": S3_CLIENT_SECRETS, "volumes": [], "networks": ["backend"]},
|
|
"s3-cli": {"secrets": S3_CLIENT_SECRETS, "volumes": [], "networks": ["backend"]},
|
|
}
|
|
|
|
|
|
def run(*command):
|
|
done = subprocess.run(command, cwd=str(ROOT), capture_output=True, text=True, check=False)
|
|
return done.returncode, done.stdout.strip()
|
|
|
|
|
|
def declared(name, service, networks, problems):
|
|
limits = service.get("deploy", {}).get("resources", {}).get("limits", {})
|
|
secrets = sorted(s["source"] for s in service.get("secrets", []))
|
|
volumes = sorted(v["source"] for v in service.get("volumes", []) if v["type"] == "volume")
|
|
nets = sorted(service.get("networks", {}))
|
|
ports = [
|
|
f"{p.get('host_ip', '0.0.0.0')}:{p.get('published')}" for p in service.get("ports", [])
|
|
]
|
|
want = POLICY.get(name)
|
|
if want is None:
|
|
problems.append(f"{name}: service is not covered by the policy")
|
|
want = {"secrets": [], "volumes": [], "networks": []}
|
|
if not limits.get("cpus") or not limits.get("memory"):
|
|
problems.append(f"{name}: no CPU or memory limit")
|
|
if "container_name" in service:
|
|
problems.append(f"{name}: container_name prevents scaling")
|
|
for kind, actual in (("secrets", secrets), ("volumes", volumes), ("networks", nets)):
|
|
if actual != want[kind]:
|
|
problems.append(f"{name}: {kind} {actual}, policy {want[kind]}")
|
|
if ports and not want.get("ports"):
|
|
problems.append(f"{name}: publishes {ports} in bypass of the balancer")
|
|
if any(not port.startswith("127.0.0.1:") for port in ports):
|
|
problems.append(f"{name}: publishes {ports} beyond loopback")
|
|
if name == "api" and not service.get("read_only"):
|
|
problems.append("api: root filesystem is writable")
|
|
internal = [n for n in nets if networks.get(n, {}).get("internal")]
|
|
return [
|
|
name,
|
|
f"{limits.get('cpus', '-')}/{int(limits.get('memory') or 0) >> 20}MiB",
|
|
",".join(ports) or "-",
|
|
",".join(secrets) or "-",
|
|
",".join(volumes) or "-",
|
|
",".join(f"{n}{'(internal)' if n in internal else ''}" for n in nets),
|
|
str(service.get("read_only", False)).lower(),
|
|
]
|
|
|
|
|
|
def running(problems):
|
|
_, ids = run("docker", "compose", "ps", "-q")
|
|
template = (
|
|
'{{index .Config.Labels "com.docker.compose.service"}} {{.Config.Hostname}} '
|
|
"{{.HostConfig.NanoCpus}} {{.HostConfig.Memory}} {{json .HostConfig.PortBindings}}"
|
|
)
|
|
_, found = run("docker", "inspect", "-f", template, *ids.split())
|
|
rows = []
|
|
for line in found.splitlines():
|
|
service, host, cpus, memory, bindings = line.split(" ", 4)
|
|
published = [
|
|
f"{b['HostIp']}:{b['HostPort']}->{port}"
|
|
for port, items in (json.loads(bindings) or {}).items()
|
|
for b in items or []
|
|
]
|
|
if int(cpus) <= 0 or int(memory) <= 0:
|
|
problems.append(f"container {service}/{host}: no CPU or memory limit applied")
|
|
if published and service != "lb":
|
|
problems.append(f"container {service}/{host}: publishes {published}")
|
|
rows.append(
|
|
[service, host, f"{int(cpus) / 1e9:g}", f"{int(memory) >> 20}MiB", ",".join(published)]
|
|
)
|
|
return sorted(rows)
|
|
|
|
|
|
def table(header, rows):
|
|
widths = [max(len(str(r[i])) for r in [header, *rows]) for i in range(len(header))]
|
|
lines = [header, ["-" * w for w in widths], *rows]
|
|
return [" ".join(str(c).ljust(w) for c, w in zip(r, widths)).rstrip() for r in lines]
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="limits, ports, secrets, volumes and networks")
|
|
parser.add_argument("--out", help="text report, written only after a complete check")
|
|
args = parser.parse_args()
|
|
problems = []
|
|
_, raw = run(
|
|
"docker",
|
|
"compose",
|
|
"--profile",
|
|
"bench",
|
|
"--profile",
|
|
"tools",
|
|
"--profile",
|
|
"reconcile",
|
|
"config",
|
|
"--format",
|
|
"json",
|
|
)
|
|
config = json.loads(raw)
|
|
services = [
|
|
declared(name, service, config.get("networks", {}), problems)
|
|
for name, service in sorted(config["services"].items())
|
|
]
|
|
containers = running(problems)
|
|
if not any(row[0] == "api" for row in containers):
|
|
problems.append("no running api replicas to inspect")
|
|
lines = [
|
|
f"date: {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}",
|
|
"$ docker compose --profile bench --profile tools --profile reconcile config --format json"
|
|
" (declared)",
|
|
*table(["service", "cpus/mem", "ports", "secrets", "volumes", "networks", "ro"], services),
|
|
"",
|
|
"$ docker inspect (running containers: hostname = X-Instance-Id, applied limits)",
|
|
*table(["service", "hostname", "cpus", "memory", "published"], containers),
|
|
"",
|
|
*(f"FAIL: {p}" for p in problems),
|
|
"PASS: limits, ports, secrets, volumes and networks match the policy"
|
|
if not problems
|
|
else f"FAIL: {len(problems)} violation(s)",
|
|
]
|
|
text = "\n".join(lines) + "\n"
|
|
if args.out:
|
|
Path(args.out).write_text(text)
|
|
print(text, end="")
|
|
return 1 if problems else 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|