forked from mtusi2026/mtusi2026lab2
scripts/limits.py states which secrets, volumes and networks each service needs and that only lb publishes ports, on loopback. It compares that policy with docker compose config (with the bench profile, so k6 is covered) and with docker inspect of the running containers: CPU and memory limits declared and applied, no container_name, no published port on any API replica, a read-only root filesystem for the API, and which networks are internal. It prints both tables and every violation and exits non-zero on any. The stack evidence script no longer reaches replicas through docker compose exec or port, which assume container number 1 and break after a rolling update renumbers the replicas. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
133 lines
5.5 KiB
Python
133 lines
5.5 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]
|
|
POLICY = {
|
|
"lb": {"secrets": [], "volumes": [], "networks": ["backend", "edge"], "ports": True},
|
|
"api": {
|
|
"secrets": ["cache_url", "cursor_secret", "database_url"],
|
|
"volumes": [],
|
|
"networks": ["backend"],
|
|
},
|
|
"migrate": {"secrets": ["database_url"], "volumes": [], "networks": ["backend"]},
|
|
"postgres": {"secrets": ["postgres_password"], "volumes": ["pgdata"], "networks": ["backend"]},
|
|
"valkey": {"secrets": ["valkey.conf"], "volumes": ["valkeydata"], "networks": ["backend"]},
|
|
"k6": {"secrets": [], "volumes": [], "networks": ["edge"]},
|
|
}
|
|
|
|
|
|
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", "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 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())
|