выполение на 5
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
kaktuz20000
2026-11-04 19:22:35 +03:00
parent 20afc2c790
commit 5a6fcff3ef
90 changed files with 8848 additions and 130 deletions
+130
View File
@@ -0,0 +1,130 @@
#!/usr/bin/env python3
import argparse
import json
import os
from pathlib import Path
import ssl
from typing import Optional
import urllib.error
import urllib.request
ROOT = Path(__file__).resolve().parents[1]
SECRET_DIR = ROOT / "secrets"
ROLE_DIR = SECRET_DIR / "openbao"
SERVICES = {
"api": ("DATABASE_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
"worker": ("DATABASE_URL", "BROKER_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
"publisher": ("DATABASE_URL", "BROKER_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
"migrate": ("DATABASE_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
"reconciler": ("DATABASE_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
}
def main() -> None:
parser = argparse.ArgumentParser(description="Provision scoped OpenBao AppRoles for this local lab.")
parser.add_argument("--root-token-file", required=True, help="Operator-only file outside version control")
parser.add_argument("--ca-file", default=str(SECRET_DIR / "pki" / "ca.crt"))
parser.add_argument("--address", default="https://localhost:8200")
args = parser.parse_args()
root_token = Path(args.root_token_file).read_text(encoding="utf-8").strip()
if not root_token:
raise SystemExit("Root token file is empty.")
ROLE_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
context = ssl.create_default_context(cafile=args.ca_file)
def request(method: str, path: str, payload: Optional[dict] = None) -> dict:
headers = {"X-Vault-Token": root_token, "Content-Type": "application/json"}
body = json.dumps(payload).encode("utf-8") if payload is not None else None
req = urllib.request.Request(
args.address.rstrip("/") + "/v1/" + path,
data=body,
headers=headers,
method=method,
)
try:
with urllib.request.urlopen(req, context=context, timeout=8) as response:
content = response.read(1024 * 1024)
return json.loads(content) if content else {}
except urllib.error.HTTPError as exc:
raise RuntimeError(f"OpenBao API request failed with HTTP {exc.code}") from None
except (urllib.error.URLError, TimeoutError, OSError, ValueError) as exc:
raise RuntimeError(f"OpenBao API request failed ({type(exc).__name__})") from None
mounts = request("GET", "sys/mounts")
if "secret/" not in mounts.get("data", {}):
request("POST", "sys/mounts/secret", {"type": "kv", "options": {"version": "2"}})
auth = request("GET", "sys/auth")
if "approle/" not in auth.get("data", {}):
request("POST", "sys/auth/approle", {"type": "approle"})
local_values = {
"DATABASE_URL": (SECRET_DIR / "database_url").read_text(encoding="utf-8").strip(),
"WORKER_DATABASE_URL": (SECRET_DIR / "worker_database_url").read_text(encoding="utf-8").strip(),
"BROKER_URL": "",
"S3_ACCESS_KEY_ID": (SECRET_DIR / "s3_access_key_id").read_text(encoding="utf-8").strip(),
"S3_SECRET_ACCESS_KEY": (SECRET_DIR / "s3_secret_access_key").read_text(encoding="utf-8").strip(),
}
service_s3_files = {
"api": ("s3_access_key_id", "s3_secret_access_key"),
**{
service: (f"{service}_s3_access_key_id", f"{service}_s3_secret_access_key")
for service in ("worker", "publisher", "migrate", "reconciler")
},
}
for service, keys in SERVICES.items():
if service in ("worker", "publisher"):
local_values["BROKER_URL"] = (
SECRET_DIR / f"broker_{service}_url"
).read_text(encoding="utf-8").strip()
policy_name = f"messenger-{service}"
policy = (
f'path "secret/data/messenger/{service}" {{\n'
' capabilities = ["read"]\n'
'}\n'
)
request("PUT", f"sys/policies/acl/{policy_name}", {"policy": policy})
request(
"POST",
f"auth/approle/role/{service}",
{
"token_policies": [policy_name],
"token_ttl": "15m",
"token_max_ttl": "1h",
"secret_id_ttl": "24h",
"secret_id_num_uses": 0,
},
)
service_values = dict(local_values)
access_key_file, secret_key_file = service_s3_files[service]
service_values["S3_ACCESS_KEY_ID"] = (
SECRET_DIR / access_key_file
).read_text(encoding="utf-8").strip()
service_values["S3_SECRET_ACCESS_KEY"] = (
SECRET_DIR / secret_key_file
).read_text(encoding="utf-8").strip()
if service == "worker":
service_values["DATABASE_URL"] = local_values["WORKER_DATABASE_URL"]
request(
"POST",
f"secret/data/messenger/{service}",
{"data": {key: service_values[key] for key in keys}},
)
role = request("GET", f"auth/approle/role/{service}/role-id")
role_id = role.get("data", {}).get("role_id")
secret = request("POST", f"auth/approle/role/{service}/secret-id", {})
secret_id = secret.get("data", {}).get("secret_id")
if not role_id or not secret_id:
raise RuntimeError(f"OpenBao did not return credentials for the {service} role")
for suffix, value in (("role_id", role_id), ("secret_id", secret_id)):
path = ROLE_DIR / f"{service}_{suffix}"
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
output.write(value + "\n")
print("OpenBao policies, scoped AppRoles and service credentials provisioned; values were not printed.")
if __name__ == "__main__":
main()
+201
View File
@@ -0,0 +1,201 @@
#!/usr/bin/env python3
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
ROOT = Path(__file__).resolve().parents[1]
PKI_DIR = ROOT / "secrets" / "pki"
def openssl(*args: str) -> None:
subprocess.run(
["openssl", *args],
check=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
def create_leaf(
work: Path,
name: str,
subject: str,
sans: str,
extended_usage: str,
ca_key: Path,
ca_cert: Path,
) -> tuple[Path, Path]:
key = PKI_DIR / f"{name}.key"
cert = PKI_DIR / f"{name}.crt"
request = work / f"{name}.csr"
extensions = work / f"{name}.ext"
openssl(
"req",
"-new",
"-newkey",
"rsa:2048",
"-nodes",
"-keyout",
str(key),
"-out",
str(request),
"-subj",
subject,
)
extensions.write_text(
"basicConstraints=critical,CA:FALSE\n"
"keyUsage=critical,digitalSignature,keyEncipherment\n"
f"extendedKeyUsage={extended_usage}\n"
f"subjectAltName={sans}\n",
encoding="ascii",
)
openssl(
"x509",
"-req",
"-in",
str(request),
"-CA",
str(ca_cert),
"-CAkey",
str(ca_key),
"-CAcreateserial",
"-out",
str(cert),
"-days",
"397",
"-sha256",
"-extfile",
str(extensions),
)
os.chmod(key, 0o600)
os.chmod(cert, 0o644)
return cert, key
def bundle(cert: Path, key: Path, output: Path) -> None:
output.write_bytes(cert.read_bytes() + key.read_bytes())
os.chmod(output, 0o600)
def main() -> None:
if PKI_DIR.exists():
raise SystemExit("PKI files already exist; rotate them with an explicit rollover procedure.")
if not shutil.which("openssl"):
raise SystemExit("OpenSSL is required to generate local certificates.")
PKI_DIR.mkdir(mode=0o700, parents=True)
ca_key = PKI_DIR / "ca.key"
ca_cert = PKI_DIR / "ca.crt"
openssl(
"req",
"-x509",
"-newkey",
"rsa:3072",
"-nodes",
"-keyout",
str(ca_key),
"-out",
str(ca_cert),
"-days",
"3650",
"-sha256",
"-subj",
"/CN=mtusi2026lab7-local-ca",
"-addext",
"basicConstraints=critical,CA:TRUE",
"-addext",
"keyUsage=critical,keyCertSign,cRLSign",
)
os.chmod(ca_key, 0o600)
os.chmod(ca_cert, 0o644)
with tempfile.TemporaryDirectory(prefix="lab7-pki-") as directory:
work = Path(directory)
foreign_ca_key = PKI_DIR / "foreign-ca.key"
foreign_ca_cert = PKI_DIR / "foreign-ca.crt"
openssl(
"req",
"-x509",
"-newkey",
"rsa:2048",
"-nodes",
"-keyout",
str(foreign_ca_key),
"-out",
str(foreign_ca_cert),
"-days",
"365",
"-sha256",
"-subj",
"/CN=mtusi2026lab7-untrusted-ca",
"-addext",
"basicConstraints=critical,CA:TRUE",
"-addext",
"keyUsage=critical,keyCertSign,cRLSign",
)
os.chmod(foreign_ca_key, 0o600)
os.chmod(foreign_ca_cert, 0o644)
ingress_cert, ingress_key = create_leaf(
work,
"ingress",
"/CN=localhost",
"DNS:localhost,IP:127.0.0.1",
"serverAuth",
ca_key,
ca_cert,
)
create_leaf(
work,
"api",
"/CN=api",
"DNS:api,IP:127.0.0.1",
"serverAuth",
ca_key,
ca_cert,
)
client_cert, client_key = create_leaf(
work,
"lb-client",
"/CN=lab7-load-balancer",
"URI:spiffe://mtusi2026lab7/load-balancer",
"clientAuth",
ca_key,
ca_cert,
)
create_leaf(
work,
"wrong-client",
"/CN=lab7-untrusted-service",
"URI:spiffe://mtusi2026lab7/other-service",
"clientAuth",
ca_key,
ca_cert,
)
create_leaf(
work,
"foreign-client",
"/CN=lab7-foreign-service",
"URI:spiffe://mtusi2026lab7/load-balancer",
"clientAuth",
foreign_ca_key,
foreign_ca_cert,
)
create_leaf(
work,
"openbao",
"/CN=openbao",
"DNS:openbao,DNS:localhost,IP:127.0.0.1",
"serverAuth",
ca_key,
ca_cert,
)
bundle(ingress_cert, ingress_key, PKI_DIR / "ingress.pem")
bundle(client_cert, client_key, PKI_DIR / "lb-client.pem")
print("Local CA and leaf certificates created under secrets/pki with private permissions.")
if __name__ == "__main__":
main()
+254
View File
@@ -0,0 +1,254 @@
#!/usr/bin/env python3
import base64
import json
import os
import secrets
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
SECRET_DIR = ROOT / "secrets"
def main():
SECRET_DIR.mkdir(mode=0o700, exist_ok=True)
os.chmod(SECRET_DIR, 0o700)
names = (
"postgres_password",
"database_url",
"worker_db_password",
"worker_database_url",
"s3_access_key_id",
"s3_secret_access_key",
"worker_s3_access_key_id",
"worker_s3_secret_access_key",
"publisher_s3_access_key_id",
"publisher_s3_secret_access_key",
"migrate_s3_access_key_id",
"migrate_s3_secret_access_key",
"reconciler_s3_access_key_id",
"reconciler_s3_secret_access_key",
"s3_admin_access_key_id",
"s3_admin_secret_access_key",
"rabbitmq_password",
"rabbitmq.conf",
"rabbitmq_definitions.json",
"broker_url",
"broker_worker_url",
"broker_publisher_url",
"s3.json",
"s3_iam.json",
"grafana_admin_password",
)
existing = [name for name in names if (SECRET_DIR / name).exists()]
if existing:
raise SystemExit(
"Secret files already exist; refusing to rotate credentials without a migration: "
+ ", ".join(existing)
)
db_password = secrets.token_hex(24)
worker_db_password = secrets.token_urlsafe(32)
broker_password = secrets.token_urlsafe(32)
worker_broker_password = secrets.token_urlsafe(32)
publisher_broker_password = secrets.token_urlsafe(32)
values = {
"postgres_password": db_password,
"database_url": (
f"postgresql://messenger:{db_password}@postgres:5432/messenger"
"?sslmode=verify-full&sslrootcert=/run/secrets/ca_crt"
),
"worker_db_password": worker_db_password,
"worker_database_url": (
f"postgresql://messenger_worker:{worker_db_password}@postgres:5432/messenger"
"?sslmode=verify-full&sslrootcert=/run/secrets/ca_crt"
),
"s3_access_key_id": "mngr" + secrets.token_hex(8),
"s3_secret_access_key": secrets.token_urlsafe(40),
"worker_s3_access_key_id": "wrk" + secrets.token_hex(8),
"worker_s3_secret_access_key": secrets.token_urlsafe(40),
"publisher_s3_access_key_id": "pub" + secrets.token_hex(8),
"publisher_s3_secret_access_key": secrets.token_urlsafe(40),
"migrate_s3_access_key_id": "mig" + secrets.token_hex(8),
"migrate_s3_secret_access_key": secrets.token_urlsafe(40),
"reconciler_s3_access_key_id": "rec" + secrets.token_hex(8),
"reconciler_s3_secret_access_key": secrets.token_urlsafe(40),
"s3_admin_access_key_id": "admin" + secrets.token_hex(7),
"s3_admin_secret_access_key": secrets.token_urlsafe(40),
"rabbitmq_password": broker_password,
"broker_url": f"amqps://worker:{worker_broker_password}@rabbitmq:5671/%2f",
"broker_worker_url": f"amqps://worker:{worker_broker_password}@rabbitmq:5671/%2f",
"broker_publisher_url": f"amqps://publisher:{publisher_broker_password}@rabbitmq:5671/%2f",
"grafana_admin_password": secrets.token_urlsafe(32),
}
for name, value in values.items():
if name.startswith("broker_") and name != "broker_url":
descriptor = os.open(SECRET_DIR / name, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
output.write(value + "\n")
continue
path = SECRET_DIR / name
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
output.write(value + "\n")
descriptor = os.open(
SECRET_DIR / "rabbitmq.conf",
os.O_WRONLY | os.O_CREAT | os.O_EXCL,
0o600,
)
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
output.write("default_user = messenger\n")
output.write(f"default_pass = {broker_password}\n")
output.write("listeners.tcp = none\n")
output.write("listeners.ssl.default = 5671\n")
output.write("ssl_options.cacertfile = /run/secrets/ca_crt\n")
output.write("ssl_options.certfile = /run/secrets/rabbitmq_tls_cert\n")
output.write("ssl_options.keyfile = /run/secrets/rabbitmq_tls_key\n")
output.write("ssl_options.verify = verify_peer\n")
output.write("ssl_options.fail_if_no_peer_cert = true\n")
output.write("ssl_options.versions.1 = tlsv1.2\n")
output.write("definitions.import_backend = local_filesystem\n")
output.write("definitions.local.path = /run/secrets/rabbitmq_definitions.json\n")
definitions = {
"users": [],
"vhosts": [{"name": "/"}],
"permissions": [],
"queues": [
{
"name": "attachments.process.dead",
"vhost": "/",
"durable": True,
"auto_delete": False,
"arguments": {"x-queue-type": "quorum", "x-quorum-initial-group-size": 1},
},
{
"name": "attachments.process.v1",
"vhost": "/",
"durable": True,
"auto_delete": False,
"arguments": {
"x-queue-type": "quorum",
"x-quorum-initial-group-size": 1,
"x-dead-letter-exchange": "",
"x-dead-letter-routing-key": "attachments.process.dead",
},
},
],
}
for username, password, configure, write, read in (
("worker", worker_broker_password, r"^$", r"^$", r"^attachments\.process\.v1$"),
("publisher", publisher_broker_password, r"^$", r"^amq\.default$", r"^$"),
):
salt = secrets.token_bytes(4)
password_hash = __import__("hashlib").sha256(salt + password.encode("utf-8")).digest()
definitions["users"].append({
"name": username,
"password_hash": __import__("base64").b64encode(salt + password_hash).decode("ascii"),
"hashing_algorithm": "rabbit_password_hashing_sha256",
"tags": "",
})
definitions["permissions"].append({
"user": username,
"vhost": "/",
"configure": configure,
"write": write,
"read": read,
})
descriptor = os.open(
SECRET_DIR / "rabbitmq_definitions.json",
os.O_WRONLY | os.O_CREAT | os.O_EXCL,
0o600,
)
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
json.dump(definitions, output, separators=(",", ":"))
output.write("\n")
os.chmod(SECRET_DIR / "rabbitmq_definitions.json", 0o644)
s3_config = {
"identities": [
{
"name": "bootstrap-admin",
"credentials": [
{
"accessKey": values["s3_admin_access_key_id"],
"secretKey": values["s3_admin_secret_access_key"],
}
],
"actions": ["Admin"],
},
{
"name": "messenger-api",
"credentials": [
{
"accessKey": values["s3_access_key_id"],
"secretKey": values["s3_secret_access_key"],
}
],
"actions": [
"Read:messenger-attachments",
"List:messenger-attachments",
"Read:messenger-variants",
"Write:messenger-staging",
],
},
{
"name": "messenger-worker",
"credentials": [{
"accessKey": values["worker_s3_access_key_id"],
"secretKey": values["worker_s3_secret_access_key"],
}],
"actions": [
"Read:messenger-staging",
"Write:messenger-staging",
"Write:messenger-attachments",
"Write:messenger-variants",
],
},
*[
{
"name": f"messenger-{service}",
"credentials": [{
"accessKey": values[f"{service}_s3_access_key_id"],
"secretKey": values[f"{service}_s3_secret_access_key"],
}],
"actions": [],
}
for service in ("publisher", "migrate")
],
{
"name": "messenger-reconciler",
"credentials": [{
"accessKey": values["reconciler_s3_access_key_id"],
"secretKey": values["reconciler_s3_secret_access_key"],
}],
"actions": [
f"{action}:{bucket}"
for bucket in ("messenger-staging", "messenger-attachments", "messenger-variants")
for action in ("Read", "Write", "List")
],
},
]
}
descriptor = os.open(SECRET_DIR / "s3.json", os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
json.dump(s3_config, output, separators=(",", ":"))
output.write("\n")
iam_config = {
"sts": {"signingKey": "base64-" + base64.urlsafe_b64encode(secrets.token_bytes(32)).decode("ascii")},
"defaultEffect": "Deny",
}
descriptor = os.open(SECRET_DIR / "s3_iam.json", os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
json.dump(iam_config, output, separators=(",", ":"))
output.write("\n")
role_dir = SECRET_DIR / "openbao"
role_dir.mkdir(mode=0o700, exist_ok=True)
for service in ("api", "worker", "publisher", "migrate", "reconciler"):
for suffix in ("role_id", "secret_id"):
path = role_dir / f"{service}_{suffix}"
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
os.close(descriptor)
print("Local secrets generated with owner-only permissions; values were not printed.")
if __name__ == "__main__":
main()
+92
View File
@@ -0,0 +1,92 @@
#!/usr/bin/env python3
import argparse
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
ROOT = Path(__file__).resolve().parents[1]
PKI_DIR = ROOT / "secrets" / "pki"
SERVICES = {
"rabbitmq": ("DNS:rabbitmq", "serverAuth"),
"s3": ("DNS:s3", "serverAuth"),
"postgres": ("DNS:postgres", "serverAuth"),
"otel-collector": ("DNS:otel-collector", "serverAuth"),
"tempo": ("DNS:tempo", "serverAuth"),
"loki": ("DNS:loki", "serverAuth"),
"prometheus": ("DNS:prometheus", "serverAuth"),
"collector-prometheus-client": ("URI:spiffe://mtusi2026lab7/collector", "clientAuth"),
"otel-api-client": ("URI:spiffe://mtusi2026lab7/api", "clientAuth"),
"otel-worker-client": ("URI:spiffe://mtusi2026lab7/worker", "clientAuth"),
"otel-publisher-client": ("URI:spiffe://mtusi2026lab7/publisher", "clientAuth"),
"rabbitmq-api-client": ("URI:spiffe://mtusi2026lab7/api", "clientAuth"),
"rabbitmq-worker-client": ("URI:spiffe://mtusi2026lab7/worker", "clientAuth"),
"rabbitmq-publisher-client": ("URI:spiffe://mtusi2026lab7/publisher", "clientAuth"),
"s3-api-client": ("URI:spiffe://mtusi2026lab7/api", "clientAuth"),
"s3-worker-client": ("URI:spiffe://mtusi2026lab7/worker", "clientAuth"),
"s3-publisher-client": ("URI:spiffe://mtusi2026lab7/publisher", "clientAuth"),
"s3-migrate-client": ("URI:spiffe://mtusi2026lab7/migrate", "clientAuth"),
"s3-reconciler-client": ("URI:spiffe://mtusi2026lab7/reconciler", "clientAuth"),
"s3-bootstrap-client": ("URI:spiffe://mtusi2026lab7/s3-bootstrap", "clientAuth"),
"s3-healthcheck-client": ("URI:spiffe://mtusi2026lab7/s3-healthcheck", "clientAuth"),
}
def openssl(*args: str) -> None:
subprocess.run(
["openssl", *args],
check=True,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
)
def main() -> None:
parser = argparse.ArgumentParser(description="Issue local short-lived mTLS service identities.")
parser.add_argument("--days", type=int, default=30)
args = parser.parse_args()
if not 1 <= args.days <= 90:
parser.error("service certificate lifetime must be between 1 and 90 days")
if not (PKI_DIR / "ca.key").is_file() or not (PKI_DIR / "ca.crt").is_file():
raise SystemExit("Create the local CA first with scripts/bootstrap-pki.py.")
if not shutil.which("openssl"):
raise SystemExit("OpenSSL is required to issue service certificates.")
missing = {
name: identity for name, identity in SERVICES.items()
if not (PKI_DIR / f"{name}.crt").exists()
}
if not missing:
raise SystemExit("All service certificates already exist; rotate them explicitly.")
with tempfile.TemporaryDirectory(prefix="lab7-service-pki-") as directory:
work = Path(directory)
for name, (san, usage) in missing.items():
key = PKI_DIR / f"{name}.key"
cert = PKI_DIR / f"{name}.crt"
csr = work / f"{name}.csr"
extension = work / f"{name}.ext"
openssl(
"req", "-new", "-newkey", "rsa:2048", "-nodes",
"-keyout", str(key), "-out", str(csr), "-subj", f"/CN={name}",
)
extension.write_text(
"basicConstraints=critical,CA:FALSE\n"
"keyUsage=critical,digitalSignature,keyEncipherment\n"
f"extendedKeyUsage={usage}\n"
f"subjectAltName={san}\n",
encoding="ascii",
)
openssl(
"x509", "-req", "-in", str(csr), "-CA", str(PKI_DIR / "ca.crt"),
"-CAkey", str(PKI_DIR / "ca.key"), "-CAcreateserial", "-out", str(cert),
"-days", str(args.days), "-sha256", "-extfile", str(extension),
)
os.chmod(key, 0o600)
os.chmod(cert, 0o644)
print(f"Issued {len(missing)} service certificates with {args.days}-day validity.")
if __name__ == "__main__":
main()
+228
View File
@@ -0,0 +1,228 @@
#!/usr/bin/env python3
import base64
import hashlib
import json
import os
from pathlib import Path
import secrets
from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
ROOT = Path(__file__).resolve().parents[1]
SECRET_DIR = ROOT / "secrets"
def read(name: str) -> str:
return (SECRET_DIR / name).read_text(encoding="utf-8").strip()
def write(name: str, content: str, replace: bool = False) -> None:
path = SECRET_DIR / name
flags = os.O_WRONLY | os.O_CREAT | (os.O_TRUNC if replace else os.O_EXCL)
descriptor = os.open(path, flags, 0o600)
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
output.write(content)
if not content.endswith("\n"):
output.write("\n")
def rabbit_user(name: str, password: str) -> dict:
salt = secrets.token_bytes(4)
digest = hashlib.sha256(salt + password.encode("utf-8")).digest()
return {
"name": name,
"password_hash": base64.b64encode(salt + digest).decode("ascii"),
"hashing_algorithm": "rabbit_password_hashing_sha256",
"tags": "",
}
def main() -> None:
os.chmod(SECRET_DIR, 0o700)
db_parts = urlsplit(read("database_url"))
query = dict(parse_qsl(db_parts.query, keep_blank_values=True))
query.update({"sslmode": "verify-full", "sslrootcert": "/run/secrets/ca_crt"})
write(
"database_url",
urlunsplit((db_parts.scheme, db_parts.netloc, db_parts.path, urlencode(query), "")),
replace=True,
)
worker_password_path = SECRET_DIR / "worker_db_password"
if not worker_password_path.exists():
write("worker_db_password", secrets.token_urlsafe(32))
worker_password = read("worker_db_password")
write(
"worker_database_url",
urlunsplit(
(
db_parts.scheme,
f"messenger_worker:{worker_password}@{db_parts.hostname}:{db_parts.port}",
db_parts.path,
urlencode(query),
"",
)
),
replace=(SECRET_DIR / "worker_database_url").exists(),
)
service_s3_credentials = {}
for service in ("worker", "publisher", "migrate", "reconciler"):
access_key_file = f"{service}_s3_access_key_id"
secret_key_file = f"{service}_s3_secret_access_key"
if not (SECRET_DIR / access_key_file).exists():
write(access_key_file, service[:3] + secrets.token_hex(8))
if not (SECRET_DIR / secret_key_file).exists():
write(secret_key_file, secrets.token_urlsafe(40))
service_s3_credentials[service] = (
read(access_key_file),
read(secret_key_file),
)
credentials = {}
users = []
permissions = []
for service, configure, write_access, read_access in (
("worker", r"^$", r"^$", r"^attachments\.process\.v1$"),
("publisher", r"^$", r"^amq\.default$", r"^$"),
):
password_file = f"rabbitmq_{service}_password"
password_path = SECRET_DIR / password_file
password = password_path.read_text(encoding="utf-8").strip() if password_path.exists() else secrets.token_urlsafe(32)
if not password_path.exists():
write(password_file, password)
credentials[service] = password
users.append(rabbit_user(service, password))
permissions.append({
"user": service,
"vhost": "/",
"configure": configure,
"write": write_access,
"read": read_access,
})
write(
f"broker_{service}_url",
f"amqps://{service}:{password}@rabbitmq:5671/%2f",
replace=(SECRET_DIR / f"broker_{service}_url").exists(),
)
definitions = {
"users": users,
"vhosts": [{"name": "/"}],
"permissions": permissions,
"queues": [
{
"name": "attachments.process.dead",
"vhost": "/",
"durable": True,
"auto_delete": False,
"arguments": {"x-queue-type": "quorum", "x-quorum-initial-group-size": 1},
},
{
"name": "attachments.process.v1",
"vhost": "/",
"durable": True,
"auto_delete": False,
"arguments": {
"x-queue-type": "quorum",
"x-quorum-initial-group-size": 1,
"x-dead-letter-exchange": "",
"x-dead-letter-routing-key": "attachments.process.dead",
},
},
],
}
definitions_path = SECRET_DIR / "rabbitmq_definitions.json"
if definitions_path.exists():
definitions_path.unlink()
write("rabbitmq_definitions.json", json.dumps(definitions, separators=(",", ":")))
os.chmod(definitions_path, 0o644)
config = (
"default_user = messenger\n"
f"default_pass = {read('rabbitmq_password')}\n"
"listeners.tcp = none\n"
"listeners.ssl.default = 5671\n"
"ssl_options.cacertfile = /run/secrets/ca_crt\n"
"ssl_options.certfile = /run/secrets/rabbitmq_tls_cert\n"
"ssl_options.keyfile = /run/secrets/rabbitmq_tls_key\n"
"ssl_options.verify = verify_peer\n"
"ssl_options.fail_if_no_peer_cert = true\n"
"ssl_options.versions.1 = tlsv1.2\n"
"definitions.import_backend = local_filesystem\n"
"definitions.local.path = /run/secrets/rabbitmq_definitions\n"
)
write("rabbitmq.conf", config, replace=True)
identities = [
{
"name": "bootstrap-admin",
"credentials": [{
"accessKey": read("s3_admin_access_key_id"),
"secretKey": read("s3_admin_secret_access_key"),
}],
"actions": ["Admin"],
},
{
"name": "messenger-api",
"credentials": [{
"accessKey": read("s3_access_key_id"),
"secretKey": read("s3_secret_access_key"),
}],
"actions": [
"Read:messenger-attachments",
"List:messenger-attachments",
"Read:messenger-variants",
"Write:messenger-staging",
],
},
{
"name": "messenger-worker",
"credentials": [{
"accessKey": service_s3_credentials["worker"][0],
"secretKey": service_s3_credentials["worker"][1],
}],
"actions": [
"Read:messenger-staging",
"Write:messenger-staging",
"Write:messenger-attachments",
"Write:messenger-variants",
],
},
*[
{
"name": f"messenger-{service}",
"credentials": [{
"accessKey": service_s3_credentials[service][0],
"secretKey": service_s3_credentials[service][1],
}],
"actions": [],
}
for service in ("publisher", "migrate")
],
{
"name": "messenger-reconciler",
"credentials": [{
"accessKey": service_s3_credentials["reconciler"][0],
"secretKey": service_s3_credentials["reconciler"][1],
}],
"actions": [
f"{action}:{bucket}"
for bucket in ("messenger-staging", "messenger-attachments", "messenger-variants")
for action in ("Read", "Write", "List")
],
},
]
write("s3.json", json.dumps({"identities": identities}, separators=(",", ":")), replace=True)
iam_config_path = SECRET_DIR / "s3_iam.json"
if not iam_config_path.exists():
iam_config = {
"sts": {
"signingKey": "base64-" + base64.urlsafe_b64encode(secrets.token_bytes(32)).decode("ascii")
},
"defaultEffect": "Deny",
}
write("s3_iam.json", json.dumps(iam_config, separators=(",", ":")))
print("TLS endpoints and service-scoped broker credentials prepared locally; values were not printed.")
if __name__ == "__main__":
main()
+33
View File
@@ -0,0 +1,33 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
interval=${RECONCILE_INTERVAL_SECONDS:-900}
grace=${RECONCILE_GRACE_SECONDS:-3600}
case "$interval" in
''|*[!0-9]*)
echo "RECONCILE_INTERVAL_SECONDS must be an integer" >&2
exit 2
;;
esac
case "$grace" in
''|*[!0-9]*)
echo "RECONCILE_GRACE_SECONDS must be an integer" >&2
exit 2
;;
esac
if [ "$interval" -lt 60 ]; then
echo "RECONCILE_INTERVAL_SECONDS must be at least 60" >&2
exit 2
fi
if [ "$grace" -lt 60 ]; then
echo "RECONCILE_GRACE_SECONDS must be at least 60" >&2
exit 2
fi
while :
do
python3 src/reconcile.py --grace-seconds "$grace" --apply
sleep "$interval"
done
+28
View File
@@ -0,0 +1,28 @@
#!/bin/sh
set -eu
docker compose --env-file .env restart postgres rabbitmq s3-core s3
for service in postgres rabbitmq s3-core s3; do
ready=0
attempt=0
while [ "$attempt" -lt 90 ]; do
ready=1
containers=$(docker compose --env-file .env ps -q "$service")
[ -n "$containers" ] || ready=0
for container in $containers; do
status=$(docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}running{{end}}' "$container")
[ "$status" = healthy ] || ready=0
done
[ "$ready" -eq 1 ] && break
attempt=$((attempt + 1))
sleep 1
done
[ "$ready" -eq 1 ] || {
printf 'Service %s did not become healthy after restart.\n' "$service" >&2
exit 1
}
done
docker compose --env-file .env restart api publisher worker reconciler
printf '%s\n' 'Restarted API and application stores without changing volumes.'
+20
View File
@@ -0,0 +1,20 @@
#!/bin/sh
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
matches=0
target_container=
for container in $(docker compose --env-file .env ps -q api); do
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$container")
if [ "$hostname" = "$TARGET_INSTANCE_ID" ]; then
matches=$((matches + 1))
target_container=$container
fi
done
if [ "$matches" -ne 1 ]; then
printf '%s\n' 'Could not resolve TARGET_INSTANCE_ID to exactly one API container.' >&2
exit 1
fi
docker stop --time 2 "$target_container" >/dev/null