Files
mtusi2026lab7/scripts/bootstrap.py
T

341 lines
12 KiB
Python

#!/usr/bin/env python3
"""Idempotent local PKI/secrets bootstrap. Operator material never enters containers."""
import json
import os
import secrets
import subprocess
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
PRIVATE = ROOT / "secrets"
OPERATOR = ROOT / "operator-private"
ROLES = (
"api",
"worker",
"dispatcher",
"lb",
"postgres",
"storage",
"broker",
"cache",
"collector",
"prometheus",
"loki",
"tempo",
"grafana",
"openbao",
"operator",
)
def write(path, text, mode=0o644):
if not path.exists():
path.write_text(text)
path.chmod(mode)
def run(*args):
subprocess.run(
["openssl", *args], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
)
def certificate(name, replace=False):
dest = PRIVATE / "pki" / name
dest.mkdir(parents=True, exist_ok=True)
dest.chmod(0o755)
if (dest / "cert.pem").exists() and not replace:
valid = subprocess.run(
["openssl", "x509", "-in", str(dest / "cert.pem"), "-checkend", "3600", "-noout"],
capture_output=True,
)
if valid.returncode == 0:
return
key, csr = dest / "key.pem", OPERATOR / (name + ".csr")
run("genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-256", "-out", str(key))
run("req", "-new", "-key", str(key), "-subj", f"/CN={name}", "-out", str(csr))
ext = OPERATOR / (name + ".ext")
names = f"DNS:{name}"
if name in {
"lb",
"api",
"postgres",
"broker",
"cache",
"collector",
"prometheus",
"loki",
"tempo",
"openbao",
"grafana",
"storage",
}:
names += ",DNS:localhost,IP:127.0.0.1"
ext.write_text(
f"subjectAltName={names}\nbasicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth,clientAuth\n"
)
run(
"x509",
"-req",
"-in",
str(csr),
"-CA",
str(OPERATOR / "ca.pem"),
"-CAkey",
str(OPERATOR / "ca-key.pem"),
"-set_serial",
str(secrets.randbits(127) or 1),
"-days",
"2",
"-extfile",
str(ext),
"-out",
str(dest / "cert.pem"),
)
key.chmod(0o644)
(dest / "combined.pem").write_text((dest / "cert.pem").read_text() + key.read_text())
(dest / "combined.pem").chmod(0o644)
def main():
os.umask(0o077)
for folder in (PRIVATE, OPERATOR):
folder.mkdir(exist_ok=True)
folder.chmod(0o700)
if not (OPERATOR / "ca-key.pem").exists():
run(
"genpkey",
"-algorithm",
"EC",
"-pkeyopt",
"ec_paramgen_curve:P-256",
"-out",
str(OPERATOR / "ca-key.pem"),
)
run(
"req",
"-x509",
"-new",
"-key",
str(OPERATOR / "ca-key.pem"),
"-subj",
"/CN=MTUSI Lab7 local CA",
"-days",
"365",
"-addext",
"basicConstraints=critical,CA:TRUE",
"-addext",
"keyUsage=critical,keyCertSign,cRLSign",
"-out",
str(OPERATOR / "ca.pem"),
)
(PRIVATE / "ca.pem").write_text((OPERATOR / "ca.pem").read_text())
(PRIVATE / "ca.pem").chmod(0o644)
(PRIVATE / "pki").mkdir(exist_ok=True)
(PRIVATE / "pki").chmod(0o755)
for name in ROLES:
certificate(name)
write(PRIVATE / "revoked.json", "[]")
for name in (
"postgres_password",
"api_db_password",
"worker_db_password",
"dispatcher_db_password",
"cache_password",
"cache_worker_password",
"cache_dispatcher_password",
"broker_worker_password",
"broker_dispatcher_password",
"broker_admin_password",
"grafana_password",
):
write(PRIVATE / name, secrets.token_urlsafe(32))
for role in ("api", "worker", "admin", "study_wide"):
write(PRIVATE / (role + "_s3_access"), role + "-" + secrets.token_hex(12))
write(PRIVATE / (role + "_s3_secret"), secrets.token_urlsafe(32))
def value(name):
return (PRIVATE / name).read_text().strip()
identities = []
for role in ("api", "worker", "admin", "study_wide"):
identities.append(
{
"name": role,
"credentials": [
{
"accessKey": value(role + "_s3_access"),
"secretKey": value(role + "_s3_secret"),
}
],
"actions": ["Admin", "Read", "Write", "List"]
if role == "admin"
else (["Read:security-study", "Write:security-study", "List:security-study"] if role == "study_wide" else ["Read:messenger", "Write:messenger", "List:messenger"]),
}
)
(PRIVATE / "s3_config").write_text(json.dumps({"identities": identities}))
(PRIVATE / "s3_config").chmod(0o644)
write(
PRIVATE / "cache_config",
'bind 127.0.0.1\nport 6379\nprotected-mode yes\nsave ""\nmaxmemory 64mb\nmaxmemory-policy allkeys-lru\nuser default off\nuser api on >'
+ value("cache_password")
+ " ~user:v1:* +get +setex +ping +hello +client|setinfo\nuser worker on >"
+ value("cache_worker_password")
+ " +ping +hello +client|setinfo\nuser dispatcher on >"
+ value("cache_dispatcher_password")
+ " +ping +hello +client|setinfo\n",
)
write(
PRIVATE / "broker_config",
'bind 127.0.0.1\nport 6379\nprotected-mode yes\nappendonly yes\nappendfsync always\nsave ""\ndir /data\nmaxmemory 128mb\nmaxmemory-policy noeviction\nuser default off\nuser operator on >'
+ value("broker_admin_password")
+ " ~* &* +@all\nuser dispatcher on >"
+ value("broker_dispatcher_password")
+ " ~attachment-jobs:v1 +xadd +ping +hello +client|setinfo\nuser worker on >"
+ value("broker_worker_password")
+ " ~attachment-jobs:v1 +xgroup|create +xreadgroup +xautoclaim +xack +xdel +ping +hello +client|setinfo\n",
)
pg = "postgresql://{role}:{password}@postgres:5432/messenger?sslmode=verify-full&sslrootcert=/run/tls/ca.pem"
values = {}
for role in ("api", "worker", "dispatcher"):
values[role] = {
"DATABASE_URL": pg.format(role=role, password=value(role + "_db_password")),
"CACHE_URL": "rediss://"
+ role
+ ":"
+ value("cache_password" if role == "api" else "cache_" + role + "_password")
+ "@cache:6380/0?ssl_cert_reqs=required&ssl_ca_certs=/run/tls/ca.pem&ssl_certfile=/run/tls/identity/cert.pem&ssl_keyfile=/run/tls/identity/key.pem",
}
if role in {"worker", "dispatcher"}:
values[role]["BROKER_URL"] = (
"rediss://"
+ role
+ ":"
+ value("broker_" + role + "_password")
+ "@broker:6380/0?ssl_cert_reqs=required&ssl_ca_certs=/run/tls/ca.pem&ssl_certfile=/run/tls/identity/cert.pem&ssl_keyfile=/run/tls/identity/key.pem"
)
if role in {"api", "worker"}:
values[role].update(
S3_ACCESS_KEY=value(role + "_s3_access"), S3_SECRET_KEY=value(role + "_s3_secret")
)
write(PRIVATE / "bao_seed.json", json.dumps(values))
write(
PRIVATE / "admin_database_url",
pg.format(role="messenger", password=value("postgres_password")),
)
write(PRIVATE / "admin_s3_access_key", value("admin_s3_access"))
write(PRIVATE / "admin_s3_secret_key", value("admin_s3_secret"))
write(
PRIVATE / "db_roles.sql",
"\n".join(
f"CREATE ROLE {role} LOGIN PASSWORD '{value(role + '_db_password')}';"
for role in ("api", "worker", "dispatcher")
),
)
gateways = {
"api": {"port": 9443, "upstream": 8080, "allowed": ["lb"]},
"broker": {
"port": 6380,
"upstream": 6379,
"allowed": ["worker", "dispatcher", "operator"],
},
"cache": {
"port": 6380,
"upstream": 6379,
"allowed": ["api", "worker", "dispatcher", "operator"],
},
"storage": {
"port": 8443,
"upstream": 8333,
"allowed": ["api", "worker", "operator"],
"http": True,
"s3": True,
},
"collector": [
{
"port": 4318,
"upstream": 14318,
"allowed": ["api", "worker", "dispatcher", "operator"],
},
{"port": 9464, "upstream": 19464, "allowed": ["prometheus", "operator"]},
{"port": 8888, "upstream": 18888, "allowed": ["prometheus", "operator"]},
],
"prometheus": {
"http": True,
"backend": "prometheus",
"port": 9443,
"upstream": 9090,
"allowed": ["grafana", "operator"],
},
"loki": {
"http": True,
"backend": "loki",
"port": 9443,
"upstream": 3100,
"allowed": ["collector", "grafana", "operator"],
},
"tempo": [
{
"port": 9443,
"upstream": 3200,
"allowed": ["grafana", "operator"],
"http": True,
"backend": "tempo",
},
{"port": 44318, "upstream": 4318, "allowed": ["collector", "operator"]},
],
}
for role, configs in gateways.items():
for item in configs if isinstance(configs, list) else [configs]:
item.update(
cert="/run/tls/identity/cert.pem",
key="/run/tls/identity/key.pem",
ca="/run/tls/ca.pem",
)
(PRIVATE / (role + "_gateway.json")).write_text(json.dumps(configs))
(PRIVATE / (role + "_gateway.json")).chmod(0o644)
provisioning = PRIVATE / "grafana-provisioning" / "datasources"
provisioning.mkdir(parents=True, exist_ok=True)
provisioning.parent.chmod(0o755)
provisioning.chmod(0o755)
datasources = []
for name in ("prometheus", "loki", "tempo"):
item = {
"name": name.title(),
"uid": name,
"type": name,
"access": "proxy",
"url": f"https://{name}:9443",
"editable": False,
"jsonData": {"tlsAuth": True, "tlsAuthWithCACert": True, "serverName": name},
"secureJsonData": {
"tlsCACert": (PRIVATE / "ca.pem").read_text(),
"tlsClientCert": (PRIVATE / "pki/grafana/cert.pem").read_text(),
"tlsClientKey": (PRIVATE / "pki/grafana/key.pem").read_text(),
},
}
if name == "prometheus":
item["isDefault"] = True
if name == "loki":
item["jsonData"]["derivedFields"] = [
{
"datasourceUid": "tempo",
"matcherRegex": '"trace_id": "([a-f0-9]{32})"',
"name": "TraceID",
"url": "$${__value.raw}",
}
]
datasources.append(item)
(provisioning / "datasources.yaml").write_text(
json.dumps({"apiVersion": 1, "datasources": datasources})
)
(provisioning / "datasources.yaml").chmod(0o644)
if not (ROOT / ".env").exists():
(ROOT / ".env").write_text("PUBLIC_PORT=8447\nSESSION_TTL_SECONDS=3600\n")
print("Local PKI and scoped credential material ready; operator CA stays outside containers.")
if __name__ == "__main__":
main()