forked from mtusi2026/mtusi2026lab2
MinIO community images can no longer be pulled on this arm64 host, so the stand runs RustFS 1.0.4 pinned by digest as non-root with a read only root, no published port, the console off and data on the s3data volume. A one-off s3-init with rc v0.1.36 creates the bucket, keeps it private for anonymous clients, creates the API user with a policy on the objects and listing of that one bucket, imports a lifecycle rule for incomplete multipart uploads and checks itself; the API replicas start only after it succeeded. Root keys reach only s3, s3-init and the operator s3-cli; the API gets its own key and the S3 settings through an anchor merged into its environment. secrets.sh creates hex S3 keys, the restart hook restarts S3 next to PostgreSQL and Valkey and waits until it is healthy, the limits policy covers the S3 services, and the stack evidence lists the new packages. The object storage adapter is tested against a throwaway RustFS of the same image: a 10 MiB round trip, a missing object, an idempotent delete and an unreachable endpoint failing within the request budget. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
157 lines
6.1 KiB
Python
157 lines
6.1 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"]},
|
|
"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",
|
|
"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 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())
|