forked from mtusi2026/mtusi2026lab7
105 lines
6.6 KiB
Python
105 lines
6.6 KiB
Python
"""lab7: раскладка стенда — реплики, сети по границам доверия, опубликованные порты, volumes, секреты, сертификаты.
|
|
|
|
python student-tests/check_stack.py
|
|
|
|
По docker compose config и docker inspect запущенных контейнеров. Значения секретов не читаются.
|
|
"""
|
|
import json
|
|
|
|
from common import BASE_URL, call, check, compose_output, docker, new_user, seen_instances
|
|
|
|
NETWORKS = { # сервис -> сети (границы доверия, contracts/trust-matrix.md)
|
|
"lb": ["frontend", "ingress"], "api": ["data", "frontend", "secrets", "telemetry"],
|
|
"worker": ["data", "secrets", "telemetry"], "dispatcher": ["data", "secrets", "telemetry"],
|
|
"janitor": ["data", "secrets", "telemetry"], "migrate": ["data", "secrets"], "s3-init": ["data", "secrets"],
|
|
"postgres": ["data"], "redis": ["data"], "s3": ["data"], "rabbitmq": ["data"],
|
|
"openbao": ["ops", "secrets"], "otel-gate": ["telemetry"], "prometheus": ["ops", "telemetry"],
|
|
"loki": ["ops", "telemetry"], "tempo": ["ops", "telemetry"], "grafana": ["ops", "telemetry"],
|
|
}
|
|
PORTS = {"lb": {8443, 8404}, "openbao": {8200}, "prometheus": {9090}, "loki": {3100}, "tempo": {3200},
|
|
"grafana": {3000}}
|
|
FILE_SECRETS = {"postgres": ["postgres_password"], "s3": ["s3_config"], "rabbitmq": ["rabbitmq_definitions"],
|
|
"grafana": ["grafana_admin_password"]}
|
|
IDENTITY = {"api": "api", "worker": "worker", "dispatcher": "dispatcher", "janitor": "janitor", "migrate": "migrate",
|
|
"s3-init": "s3-init", "postgres": "postgres", "redis": "redis", "s3": "s3", "rabbitmq": "rabbitmq",
|
|
"openbao": "openbao", "otel-gate": "otel-collector", "otel-collector": "otel-collector",
|
|
"prometheus": "prometheus", "loki": "loki", "tempo": "tempo", "grafana": "grafana"}
|
|
STATEFUL = {"postgres": "/var/lib/postgresql/data", "redis": "/data", "s3": "/data", "rabbitmq": "/var/lib/rabbitmq",
|
|
"openbao": "/openbao/file", "prometheus": "/prometheus", "loki": "/loki", "tempo": "/var/tempo",
|
|
"grafana": "/var/lib/grafana"}
|
|
|
|
|
|
def main():
|
|
config = json.loads(compose_output("config", "--format", "json"))
|
|
services = config["services"]
|
|
for one_shot in ("migrate", "s3-init", "telemetry-init"):
|
|
status = compose_output("ps", "-a", "--format", "{{.Status}}", one_shot).strip()
|
|
print(f"{one_shot}: {status}")
|
|
check(status.startswith("Exited (0)"), f"{one_shot} must finish with exit code 0")
|
|
|
|
ids = compose_output("ps", "-q").split()
|
|
rows = [json.loads(line) for line in docker("inspect", "--format", "{{json .}}", *ids).splitlines()]
|
|
print("\ncontainer image cpus memory pids host ports networks")
|
|
api_count, running = 0, set()
|
|
for row in sorted(rows, key=lambda r: r["Name"]):
|
|
service = row["Config"]["Labels"].get("com.docker.compose.service")
|
|
running.add(service)
|
|
host = row["HostConfig"]
|
|
cpus, memory = host.get("NanoCpus", 0) / 1e9, host.get("Memory", 0) / 2 ** 20
|
|
ports = sorted({f"{b['HostIp']}:{b['HostPort']}" for bindings in (row["NetworkSettings"]["Ports"] or {}).values()
|
|
for b in (bindings or [])})
|
|
networks = sorted(row["NetworkSettings"]["Networks"])
|
|
print(f"{row['Name'][1:]:<28} {row['Config']['Image'][:38]:<38} {cpus:>4} {memory:>6.0f}M {host.get('PidsLimit')!s:>5}"
|
|
f" {','.join(ports) or '-':<19} {','.join(n.split('_', 1)[-1] for n in networks)}")
|
|
check(cpus > 0 and memory > 0 and host.get("PidsLimit"), f"{service}: CPU/RAM/PID limit missing")
|
|
published = {int(p.rsplit(":", 1)[1]) for p in ports}
|
|
check(published == PORTS.get(service, set()), f"{service}: published ports {published}")
|
|
check(all(p.startswith("127.0.0.1:") for p in ports), f"{service}: ports must bind 127.0.0.1 only")
|
|
if service == "api":
|
|
api_count += 1
|
|
check(api_count >= 2, "need at least 2 api replicas")
|
|
|
|
for name, expected in NETWORKS.items():
|
|
got = sorted(services[name].get("networks", {}))
|
|
check(got == sorted(expected), f"{name}: networks {got}, expected {sorted(expected)}")
|
|
check(services["otel-collector"].get("network_mode") == "service:otel-gate", "collector must share gate netns")
|
|
for net in ("frontend", "data", "secrets", "telemetry"):
|
|
check(config["networks"][net].get("internal") is True, f"network {net} must be internal")
|
|
print("\nnetworks: ingress (lb only, 127.0.0.1:8443/8404) | frontend lb<->api | data | secrets | telemetry — "
|
|
"all internal except ingress/ops")
|
|
|
|
for name, path in STATEFUL.items():
|
|
check(any(v.get("target") == path and v.get("type") == "volume" for v in services[name].get("volumes", [])),
|
|
f"{name}: data must be in a named volume")
|
|
for name, svc in services.items():
|
|
image = svc.get("image") or ""
|
|
check(not image.endswith(":latest"), f"{name}: image version must be pinned")
|
|
secrets = sorted(s["source"] for s in svc.get("secrets", []))
|
|
check(secrets == FILE_SECRETS.get(name, []), f"{name}: file secrets {secrets}")
|
|
tls = [v for v in svc.get("volumes", []) if v.get("target") in ("/run/tls", "/run/tls-lb", "/run/tls-ingress")]
|
|
if name in IDENTITY:
|
|
check(tls and all(v.get("read_only") for v in tls), f"{name}: certificate must be mounted read-only")
|
|
check(any(v["source"].replace("\\", "/").endswith(f"secrets/pki/{IDENTITY[name]}") for v in tls),
|
|
f"{name}: must mount only its own identity {IDENTITY[name]}")
|
|
sources = [v.get("source", "").replace("\\", "/") for v in svc.get("volumes", [])]
|
|
check(not any(s.endswith("secrets/pki/ca") or s.endswith("secrets/operator") or s.endswith("secrets/pki")
|
|
for s in sources), f"{name}: CA key / operator files must never be mounted")
|
|
print("file secrets: only postgres (initdb), s3 (key config), rabbitmq (definitions), grafana (admin) — the "
|
|
"application gets credentials from OpenBao; every service mounts only its own certificate; CA key and "
|
|
"operator files are mounted nowhere")
|
|
|
|
user = new_user("stack")
|
|
served = seen_instances(user["token"], 20)
|
|
print(f"through {BASE_URL} one session is served by {len(served)} replicas: {sorted(served)}")
|
|
check(len(served) >= 2, "requests are not balanced")
|
|
call("GET", "/health/ready", 200)
|
|
print("PASS: stand layout matches the trust boundaries")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
main()
|
|
except AssertionError as exc:
|
|
print(f"FAIL: {exc}")
|
|
raise SystemExit(1)
|