Lab7: HTTPS, mTLS, OpenBao, трек 2 PKI на оценку 5
Skeleton contracts / contracts (pull_request) Canceled after 0s
Skeleton contracts / contracts (pull_request) Canceled after 0s
This commit is contained in:
@@ -0,0 +1,100 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Создать локальные .env, secrets и PKI. Значения секретов в консоль не печатаются."""
|
||||
import secrets
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
SECRET_DIR = ROOT / "secrets"
|
||||
PASSWORD_FILE = SECRET_DIR / "postgres_password"
|
||||
DATABASE_FILE = SECRET_DIR / "database_url"
|
||||
CACHE_FILE = SECRET_DIR / "cache_url"
|
||||
MINIO_USER_FILE = SECRET_DIR / "minio_root_user"
|
||||
MINIO_PASSWORD_FILE = SECRET_DIR / "minio_root_password"
|
||||
S3_ACCESS_FILE = SECRET_DIR / "s3_access_key"
|
||||
S3_SECRET_FILE = SECRET_DIR / "s3_secret_key"
|
||||
RABBIT_USER_FILE = SECRET_DIR / "rabbit_user"
|
||||
RABBIT_PASSWORD_FILE = SECRET_DIR / "rabbit_password"
|
||||
BROKER_FILE = SECRET_DIR / "broker_url"
|
||||
BAO_FILES = (
|
||||
SECRET_DIR / "bao_api_role_id",
|
||||
SECRET_DIR / "bao_api_secret_id",
|
||||
SECRET_DIR / "bao_worker_role_id",
|
||||
SECRET_DIR / "bao_worker_secret_id",
|
||||
)
|
||||
ENV_FILE = ROOT / ".env"
|
||||
ENV_EXAMPLE = ROOT / ".env.example"
|
||||
|
||||
|
||||
def main():
|
||||
SECRET_DIR.mkdir(exist_ok=True)
|
||||
code = subprocess.call([sys.executable, "-X", "utf8", str(ROOT / "scripts" / "bootstrap_pki.py")])
|
||||
if code != 0:
|
||||
return code
|
||||
|
||||
files = (PASSWORD_FILE, DATABASE_FILE, CACHE_FILE)
|
||||
if any(path.exists() for path in files) and not all(path.exists() for path in files):
|
||||
print("secrets/ заполнены не полностью, ничего не перезаписываю", file=sys.stderr)
|
||||
return 1
|
||||
if all(path.exists() for path in files):
|
||||
print("db/cache secrets already exist")
|
||||
else:
|
||||
password = secrets.token_hex(24)
|
||||
PASSWORD_FILE.write_text(password + "\n", encoding="utf-8")
|
||||
DATABASE_FILE.write_text(
|
||||
"postgresql://messenger:{}@postgres:5432/messenger"
|
||||
"?sslmode=verify-full&sslrootcert=/certs/ca.crt\n".format(password),
|
||||
encoding="utf-8",
|
||||
)
|
||||
CACHE_FILE.write_text("rediss://redis:6379/0\n", encoding="utf-8")
|
||||
print("db/cache secrets created")
|
||||
|
||||
s3_files = (MINIO_USER_FILE, MINIO_PASSWORD_FILE, S3_ACCESS_FILE, S3_SECRET_FILE)
|
||||
if any(path.exists() for path in s3_files) and not all(path.exists() for path in s3_files):
|
||||
print("secrets/ для MinIO заполнены не полностью, ничего не перезаписываю", file=sys.stderr)
|
||||
return 1
|
||||
if all(path.exists() for path in s3_files):
|
||||
print("s3 secrets already exist")
|
||||
else:
|
||||
MINIO_USER_FILE.write_text("labroot", encoding="utf-8")
|
||||
MINIO_PASSWORD_FILE.write_text(secrets.token_hex(24), encoding="utf-8")
|
||||
S3_ACCESS_FILE.write_text("api" + secrets.token_hex(8), encoding="utf-8")
|
||||
S3_SECRET_FILE.write_text(secrets.token_hex(24), encoding="utf-8")
|
||||
print("s3 secrets created")
|
||||
|
||||
broker_files = (RABBIT_USER_FILE, RABBIT_PASSWORD_FILE, BROKER_FILE)
|
||||
if any(path.exists() for path in broker_files) and not all(path.exists() for path in broker_files):
|
||||
print("secrets/ для брокера заполнены не полностью, ничего не перезаписываю", file=sys.stderr)
|
||||
return 1
|
||||
if all(path.exists() for path in broker_files):
|
||||
print("broker secrets already exist")
|
||||
else:
|
||||
user = "lab"
|
||||
password = secrets.token_hex(24)
|
||||
RABBIT_USER_FILE.write_text(user, encoding="utf-8")
|
||||
RABBIT_PASSWORD_FILE.write_text(password, encoding="utf-8")
|
||||
BROKER_FILE.write_text(
|
||||
"amqps://{}:{}@rabbitmq:5671/%2F\n".format(user, password),
|
||||
encoding="utf-8",
|
||||
)
|
||||
print("broker secrets created")
|
||||
|
||||
for path in BAO_FILES:
|
||||
if not path.exists():
|
||||
# Заглушка до scripts/openbao_bootstrap.py; compose требует файл.
|
||||
path.write_text("pending-openbao-bootstrap\n", encoding="utf-8")
|
||||
print("openbao secret placeholders ready (run openbao_bootstrap after openbao is up)")
|
||||
|
||||
if ENV_FILE.exists():
|
||||
print(".env already exists")
|
||||
else:
|
||||
text = ENV_EXAMPLE.read_text(encoding="utf-8")
|
||||
text = text.replace("APP_PORT=8080", "APP_PORT=8443")
|
||||
ENV_FILE.write_text(text, encoding="utf-8")
|
||||
print(".env created")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,220 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Create the local Lab 7 CA and service certificates without printing keys."""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import shutil
|
||||
import stat
|
||||
import subprocess
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
CERT_DIR = ROOT / "certs"
|
||||
PRIVATE_DIR = CERT_DIR / "private"
|
||||
OPENSSL_IMAGE = "alpine/openssl:3.3.2"
|
||||
|
||||
SERVER_IDENTITIES = {
|
||||
"public": ["DNS:localhost", "IP:127.0.0.1"],
|
||||
"api": ["DNS:api"],
|
||||
"rabbitmq": ["DNS:rabbitmq"],
|
||||
"otel-collector": ["DNS:otel-collector", "DNS:otel-gateway"],
|
||||
"openbao": ["DNS:openbao", "IP:127.0.0.1"],
|
||||
"postgres": ["DNS:postgres"],
|
||||
"redis": ["DNS:redis"],
|
||||
"minio": ["DNS:minio"],
|
||||
}
|
||||
CLIENT_IDENTITIES = ("lb", "worker-client", "api-client")
|
||||
|
||||
|
||||
def _find_openssl() -> str | None:
|
||||
found = shutil.which("openssl")
|
||||
if found:
|
||||
return found
|
||||
for candidate in (
|
||||
r"C:\Program Files\Git\usr\bin\openssl.exe",
|
||||
r"C:\Program Files (x86)\Git\usr\bin\openssl.exe",
|
||||
):
|
||||
if Path(candidate).exists():
|
||||
return candidate
|
||||
return None
|
||||
|
||||
|
||||
def _container_path(path: Path) -> str:
|
||||
return "/work/" + path.resolve().relative_to(ROOT.resolve()).as_posix()
|
||||
|
||||
|
||||
def _run_openssl(args: list[str]) -> None:
|
||||
executable = _find_openssl()
|
||||
if executable:
|
||||
command = [executable, *args]
|
||||
else:
|
||||
if not shutil.which("docker"):
|
||||
raise RuntimeError("openssl and docker are both unavailable")
|
||||
converted = []
|
||||
for arg in args:
|
||||
try:
|
||||
converted.append(_container_path(Path(arg)) if Path(arg).is_absolute() else arg)
|
||||
except ValueError:
|
||||
converted.append(arg)
|
||||
command = [
|
||||
"docker",
|
||||
"run",
|
||||
"--rm",
|
||||
"-v",
|
||||
f"{ROOT}:/work",
|
||||
"-w",
|
||||
"/work",
|
||||
OPENSSL_IMAGE,
|
||||
*converted,
|
||||
]
|
||||
subprocess.run(command, check=True, stdout=subprocess.DEVNULL)
|
||||
|
||||
|
||||
def _protect(path: Path) -> None:
|
||||
try:
|
||||
path.chmod(stat.S_IRUSR | stat.S_IWUSR)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
def _write_extension(identity: str, sans: list[str], usage: str) -> Path:
|
||||
handle = tempfile.NamedTemporaryFile(
|
||||
mode="w", encoding="utf-8", prefix=f"{identity}-", suffix=".cnf", dir=CERT_DIR, delete=False
|
||||
)
|
||||
with handle:
|
||||
handle.write("[v3]\n")
|
||||
handle.write("basicConstraints=critical,CA:FALSE\n")
|
||||
handle.write("keyUsage=critical,digitalSignature,keyEncipherment\n")
|
||||
handle.write(f"extendedKeyUsage={usage}\n")
|
||||
if sans:
|
||||
handle.write("subjectAltName=" + ",".join(sans) + "\n")
|
||||
return Path(handle.name)
|
||||
|
||||
|
||||
def issue_leaf(identity: str, days: int = 90, force: bool = False) -> tuple[Path, Path]:
|
||||
if identity in SERVER_IDENTITIES:
|
||||
sans = SERVER_IDENTITIES[identity]
|
||||
usage = "serverAuth,clientAuth" if identity != "public" else "serverAuth"
|
||||
elif identity in CLIENT_IDENTITIES or identity == "rollover-demo":
|
||||
sans = [f"DNS:{identity}"]
|
||||
usage = "clientAuth"
|
||||
else:
|
||||
raise ValueError(f"unknown PKI identity: {identity}")
|
||||
|
||||
cert = CERT_DIR / f"{identity}.crt"
|
||||
key = PRIVATE_DIR / f"{identity}.key"
|
||||
if cert.exists() and key.exists() and not force:
|
||||
return cert, key
|
||||
|
||||
csr = CERT_DIR / f".{identity}.csr"
|
||||
serial = CERT_DIR / "ca.srl"
|
||||
extension = _write_extension(identity, sans, usage)
|
||||
try:
|
||||
_run_openssl(
|
||||
[
|
||||
"req",
|
||||
"-new",
|
||||
"-newkey",
|
||||
"rsa:2048",
|
||||
"-nodes",
|
||||
"-keyout",
|
||||
str(key),
|
||||
"-out",
|
||||
str(csr),
|
||||
"-subj",
|
||||
f"/O=MTUSI Lab 7/CN={identity}",
|
||||
]
|
||||
)
|
||||
command = [
|
||||
"x509",
|
||||
"-req",
|
||||
"-in",
|
||||
str(csr),
|
||||
"-CA",
|
||||
str(CERT_DIR / "ca.crt"),
|
||||
"-CAkey",
|
||||
str(PRIVATE_DIR / "ca.key"),
|
||||
"-out",
|
||||
str(cert),
|
||||
"-days",
|
||||
str(days),
|
||||
"-sha256",
|
||||
"-extfile",
|
||||
str(extension),
|
||||
"-extensions",
|
||||
"v3",
|
||||
]
|
||||
if serial.exists():
|
||||
command.extend(["-CAserial", str(serial)])
|
||||
else:
|
||||
command.append("-CAcreateserial")
|
||||
_run_openssl(command)
|
||||
finally:
|
||||
csr.unlink(missing_ok=True)
|
||||
extension.unlink(missing_ok=True)
|
||||
_protect(key)
|
||||
return cert, key
|
||||
|
||||
|
||||
def _combined(identity: str) -> None:
|
||||
target = PRIVATE_DIR / f"{identity}.pem"
|
||||
cert = CERT_DIR / f"{identity}.crt"
|
||||
key = PRIVATE_DIR / f"{identity}.key"
|
||||
target.write_bytes(cert.read_bytes() + key.read_bytes())
|
||||
_protect(target)
|
||||
|
||||
|
||||
def bootstrap(force: bool = False, days: int = 90) -> None:
|
||||
CERT_DIR.mkdir(exist_ok=True)
|
||||
PRIVATE_DIR.mkdir(exist_ok=True)
|
||||
ca_cert = CERT_DIR / "ca.crt"
|
||||
ca_key = PRIVATE_DIR / "ca.key"
|
||||
if force or not (ca_cert.exists() and ca_key.exists()):
|
||||
_run_openssl(
|
||||
[
|
||||
"req",
|
||||
"-x509",
|
||||
"-newkey",
|
||||
"rsa:4096",
|
||||
"-nodes",
|
||||
"-keyout",
|
||||
str(ca_key),
|
||||
"-out",
|
||||
str(ca_cert),
|
||||
"-days",
|
||||
"3650",
|
||||
"-sha256",
|
||||
"-subj",
|
||||
"/O=MTUSI Lab 7/CN=ca",
|
||||
"-addext",
|
||||
"basicConstraints=critical,CA:TRUE,pathlen:0",
|
||||
"-addext",
|
||||
"keyUsage=critical,keyCertSign,cRLSign",
|
||||
]
|
||||
)
|
||||
_protect(ca_key)
|
||||
|
||||
for identity in (*SERVER_IDENTITIES, *CLIENT_IDENTITIES):
|
||||
issue_leaf(identity, days=days, force=force)
|
||||
_combined("public")
|
||||
_combined("lb")
|
||||
revoked = CERT_DIR / "revoked_serials.txt"
|
||||
if not revoked.exists():
|
||||
revoked.write_text("# one uppercase certificate serial per line\n", encoding="ascii")
|
||||
print("PKI ready: public certificates are in certs/; private keys remain in ignored certs/private/")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--force", action="store_true", help="replace the CA and every leaf")
|
||||
parser.add_argument("--days", type=int, default=90)
|
||||
args = parser.parse_args()
|
||||
if args.days < 1:
|
||||
parser.error("--days must be at least 1")
|
||||
bootstrap(force=args.force, days=args.days)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,30 @@
|
||||
#!/bin/sh
|
||||
# Идемпотентно создаёт приватный bucket и отдельного пользователя API.
|
||||
set -eu
|
||||
ROOT_USER=$(tr -d '\r\n' < /run/secrets/minio_root_user)
|
||||
ROOT_PW=$(tr -d '\r\n' < /run/secrets/minio_root_password)
|
||||
ACCESS=$(tr -d '\r\n' < /run/secrets/s3_access_key)
|
||||
SECRET=$(tr -d '\r\n' < /run/secrets/s3_secret_key)
|
||||
|
||||
export SSL_CERT_FILE=/certs/ca.crt
|
||||
attempt=0
|
||||
until mc alias set local https://minio:9000 "$ROOT_USER" "$ROOT_PW" >/dev/null; do
|
||||
attempt=$((attempt + 1))
|
||||
if [ "$attempt" -gt 40 ]; then
|
||||
echo "minio alias failed" >&2
|
||||
exit 1
|
||||
fi
|
||||
sleep 1
|
||||
done
|
||||
|
||||
mc mb --ignore-existing local/messenger-attachments >/dev/null
|
||||
mc anonymous set none local/messenger-attachments >/dev/null
|
||||
|
||||
if ! mc admin user info local "$ACCESS" >/dev/null 2>&1; then
|
||||
mc admin user add local "$ACCESS" "$SECRET" >/dev/null
|
||||
fi
|
||||
mc admin policy detach local messenger-api --user "$ACCESS" >/dev/null 2>&1 || true
|
||||
mc admin policy rm local messenger-api >/dev/null 2>&1 || true
|
||||
mc admin policy create local messenger-api /init/policy.json >/dev/null
|
||||
mc admin policy attach local messenger-api --user "$ACCESS" >/dev/null
|
||||
echo "minio bucket ready"
|
||||
@@ -0,0 +1,8 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
mkdir -p /root/.minio/certs/CAs
|
||||
cp /tls/minio.crt /root/.minio/certs/public.crt
|
||||
cp /tls/minio.key /root/.minio/certs/private.key
|
||||
cp /tls/ca.crt /root/.minio/certs/CAs/ca.crt
|
||||
chmod 600 /root/.minio/certs/private.key
|
||||
exec minio server /data --address :9000 --console-address 127.0.0.1:9001
|
||||
@@ -0,0 +1,13 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
mkdir -p /openbao/tls-run
|
||||
cp /openbao/tls/openbao.crt /openbao/tls-run/openbao.crt
|
||||
cp /openbao/tls/openbao.key /openbao/tls-run/openbao.key
|
||||
cp /openbao/tls/ca.crt /openbao/tls-run/ca.crt
|
||||
chmod 600 /openbao/tls-run/openbao.key
|
||||
chmod 644 /openbao/tls-run/openbao.crt /openbao/tls-run/ca.crt
|
||||
# Подменить пути в runtime-конфиге
|
||||
sed 's|/openbao/tls/openbao.crt|/openbao/tls-run/openbao.crt|; s|/openbao/tls/openbao.key|/openbao/tls-run/openbao.key|' \
|
||||
/openbao/config/openbao.hcl > /tmp/openbao.hcl
|
||||
export BAO_CACERT=/openbao/tls-run/ca.crt
|
||||
exec bao server -config=/tmp/openbao.hcl
|
||||
@@ -0,0 +1,166 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Операторский init/unseal OpenBao + AppRole/policies. Tokens/shares не печатаются."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import ssl
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
SECRET_DIR = ROOT / "secrets"
|
||||
BAO_DIR = SECRET_DIR / "openbao"
|
||||
CA = ROOT / "certs" / "ca.crt"
|
||||
ADDR = os.environ.get("BAO_ADDR", "https://127.0.0.1:8200").rstrip("/")
|
||||
|
||||
|
||||
def ctx() -> ssl.SSLContext:
|
||||
context = ssl.create_default_context(cafile=str(CA))
|
||||
context.minimum_version = ssl.TLSVersion.TLSv1_2
|
||||
# cert SAN is openbao; operator talks via 127.0.0.1 publish
|
||||
context.check_hostname = False
|
||||
return context
|
||||
|
||||
|
||||
def call(method: str, path: str, body=None, token: str | None = None) -> dict:
|
||||
data = None
|
||||
headers = {"Accept": "application/json"}
|
||||
if body is not None:
|
||||
data = json.dumps(body).encode("utf-8")
|
||||
headers["Content-Type"] = "application/json"
|
||||
if token:
|
||||
headers["X-Vault-Token"] = token
|
||||
req = urllib.request.Request(ADDR + path, data=data, headers=headers, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, context=ctx(), timeout=10) as response:
|
||||
raw = response.read().decode("utf-8")
|
||||
except urllib.error.HTTPError as exc:
|
||||
raw = exc.read().decode("utf-8")
|
||||
if exc.code >= 400:
|
||||
raise RuntimeError(f"{method} {path} -> {exc.code}: {raw[:200]}") from exc
|
||||
return json.loads(raw) if raw else {}
|
||||
return json.loads(raw) if raw else {}
|
||||
|
||||
|
||||
def write_secret(path: Path, value: str) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(value.strip() + "\n", encoding="utf-8")
|
||||
|
||||
|
||||
def wait_up() -> None:
|
||||
for _ in range(60):
|
||||
try:
|
||||
call("GET", "/v1/sys/health?sealedcode=200&uninitcode=200&standbycode=200")
|
||||
return
|
||||
except Exception:
|
||||
time.sleep(2)
|
||||
raise RuntimeError("openbao not reachable")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
wait_up()
|
||||
BAO_DIR.mkdir(parents=True, exist_ok=True)
|
||||
root_file = BAO_DIR / "root_token"
|
||||
unseal_file = BAO_DIR / "unseal_key"
|
||||
|
||||
status = call("GET", "/v1/sys/seal-status")
|
||||
if not status.get("initialized"):
|
||||
result = call("PUT", "/v1/sys/init", {"secret_shares": 1, "secret_threshold": 1})
|
||||
keys = result.get("keys_base64") or result.get("keys")
|
||||
root = result.get("root_token")
|
||||
if not keys or not root:
|
||||
raise RuntimeError("init failed")
|
||||
write_secret(unseal_file, keys[0])
|
||||
write_secret(root_file, root)
|
||||
print("OpenBao initialized (keys stored under secrets/openbao/, not printed)")
|
||||
else:
|
||||
if not root_file.exists() or not unseal_file.exists():
|
||||
print("OpenBao already initialized but local operator keys missing", file=sys.stderr)
|
||||
return 2
|
||||
print("OpenBao already initialized")
|
||||
|
||||
root = root_file.read_text(encoding="utf-8").strip()
|
||||
unseal = unseal_file.read_text(encoding="utf-8").strip()
|
||||
status = call("GET", "/v1/sys/seal-status")
|
||||
if status.get("sealed"):
|
||||
call("PUT", "/v1/sys/unseal", {"key": unseal})
|
||||
print("OpenBao unsealed")
|
||||
else:
|
||||
print("OpenBao already unsealed")
|
||||
|
||||
# Enable secrets/auth (ignore already-exists)
|
||||
try:
|
||||
call("POST", "/v1/sys/mounts/secret", {"type": "kv", "options": {"version": "2"}}, token=root)
|
||||
except RuntimeError as exc:
|
||||
if "already in use" not in str(exc).lower() and "existing mount" not in str(exc).lower():
|
||||
# Vault returns 400 if exists
|
||||
if "400" not in str(exc):
|
||||
raise
|
||||
try:
|
||||
call("POST", "/v1/sys/auth/approle", {"type": "approle"}, token=root)
|
||||
except RuntimeError as exc:
|
||||
if "path is already in use" not in str(exc).lower() and "400" not in str(exc):
|
||||
raise
|
||||
|
||||
api_policy = (ROOT / "infra/openbao/policies/api.hcl").read_text(encoding="utf-8")
|
||||
worker_policy = (ROOT / "infra/openbao/policies/worker.hcl").read_text(encoding="utf-8")
|
||||
call("PUT", "/v1/sys/policies/acl/messenger-api", {"policy": api_policy}, token=root)
|
||||
call("PUT", "/v1/sys/policies/acl/messenger-worker", {"policy": worker_policy}, token=root)
|
||||
|
||||
call(
|
||||
"POST",
|
||||
"/v1/auth/approle/role/messenger-api",
|
||||
{
|
||||
"token_policies": ["messenger-api"],
|
||||
"token_ttl": "5m",
|
||||
"token_max_ttl": "15m",
|
||||
"secret_id_ttl": "720h",
|
||||
},
|
||||
token=root,
|
||||
)
|
||||
call(
|
||||
"POST",
|
||||
"/v1/auth/approle/role/messenger-worker",
|
||||
{
|
||||
"token_policies": ["messenger-worker"],
|
||||
"token_ttl": "5m",
|
||||
"token_max_ttl": "15m",
|
||||
"secret_id_ttl": "720h",
|
||||
},
|
||||
token=root,
|
||||
)
|
||||
|
||||
call(
|
||||
"POST",
|
||||
"/v1/secret/data/messenger/api",
|
||||
{"data": {"purpose": "api-runtime", "note": "scoped-lab7"}},
|
||||
token=root,
|
||||
)
|
||||
call(
|
||||
"POST",
|
||||
"/v1/secret/data/messenger/worker",
|
||||
{"data": {"purpose": "worker-runtime", "note": "scoped-lab7"}},
|
||||
token=root,
|
||||
)
|
||||
|
||||
api_role = call("GET", "/v1/auth/approle/role/messenger-api/role-id", token=root)["data"]["role_id"]
|
||||
worker_role = call("GET", "/v1/auth/approle/role/messenger-worker/role-id", token=root)["data"]["role_id"]
|
||||
api_secret = call("POST", "/v1/auth/approle/role/messenger-api/secret-id", {}, token=root)["data"]["secret_id"]
|
||||
worker_secret = call("POST", "/v1/auth/approle/role/messenger-worker/secret-id", {}, token=root)["data"][
|
||||
"secret_id"
|
||||
]
|
||||
|
||||
write_secret(SECRET_DIR / "bao_api_role_id", api_role)
|
||||
write_secret(SECRET_DIR / "bao_api_secret_id", api_secret)
|
||||
write_secret(SECRET_DIR / "bao_worker_role_id", worker_role)
|
||||
write_secret(SECRET_DIR / "bao_worker_secret_id", worker_secret)
|
||||
print("AppRole credentials written to secrets/bao_*; recreate api/worker to pick them up")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,28 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Track 2: перевыпуск leaf без пересборки образов. Приватные ключи не печатаются."""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "scripts"))
|
||||
from bootstrap_pki import _combined, issue_leaf # noqa: E402
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--identity", required=True)
|
||||
parser.add_argument("--days", type=int, default=7)
|
||||
args = parser.parse_args()
|
||||
issue_leaf(args.identity, days=args.days, force=True)
|
||||
if args.identity in {"public", "lb"}:
|
||||
_combined(args.identity)
|
||||
print(f"renewed {args.identity} for {args.days} days; recreate dependent containers to load new leaf")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,19 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
mkdir -p /var/lib/postgresql/tls
|
||||
cp /tls/postgres.crt /var/lib/postgresql/tls/server.crt
|
||||
cp /tls/postgres.key /var/lib/postgresql/tls/server.key
|
||||
cp /tls/ca.crt /var/lib/postgresql/tls/ca.crt
|
||||
chown -R postgres:postgres /var/lib/postgresql/tls
|
||||
chmod 600 /var/lib/postgresql/tls/server.key
|
||||
chmod 644 /var/lib/postgresql/tls/server.crt /var/lib/postgresql/tls/ca.crt
|
||||
exec docker-entrypoint.sh postgres \
|
||||
-c fsync=on \
|
||||
-c synchronous_commit=on \
|
||||
-c full_page_writes=on \
|
||||
-c max_connections=80 \
|
||||
-c shared_buffers=64MB \
|
||||
-c ssl=on \
|
||||
-c ssl_cert_file=/var/lib/postgresql/tls/server.crt \
|
||||
-c ssl_key_file=/var/lib/postgresql/tls/server.key \
|
||||
-c ssl_ca_file=/var/lib/postgresql/tls/ca.crt
|
||||
@@ -0,0 +1,29 @@
|
||||
#!/bin/sh
|
||||
# Пароль и TLS: конфиг только внутри контейнера, секреты не в git.
|
||||
set -eu
|
||||
user=$(tr -d '\r\n' < /run/secrets/rabbit_user)
|
||||
pass=$(tr -d '\r\n' < /run/secrets/rabbit_password)
|
||||
mkdir -p /tmp/rabbit-conf /tmp/rabbit-tls
|
||||
cp /tls/rabbitmq.crt /tmp/rabbit-tls/server.crt
|
||||
cp /tls/rabbitmq.key /tmp/rabbit-tls/server.key
|
||||
cp /tls/ca.crt /tmp/rabbit-tls/ca.crt
|
||||
# rabbitmq-пользователь должен читать key (Windows bind mount часто root-only).
|
||||
chown -R rabbitmq:rabbitmq /tmp/rabbit-tls 2>/dev/null || true
|
||||
chmod 640 /tmp/rabbit-tls/server.key
|
||||
chmod 644 /tmp/rabbit-tls/server.crt /tmp/rabbit-tls/ca.crt
|
||||
cat > /tmp/rabbit-conf/rabbitmq.conf <<EOF
|
||||
default_user = ${user}
|
||||
default_pass = ${pass}
|
||||
vm_memory_high_watermark.absolute = 768MB
|
||||
listeners.tcp = none
|
||||
listeners.ssl.default = 5671
|
||||
ssl_options.cacertfile = /tmp/rabbit-tls/ca.crt
|
||||
ssl_options.certfile = /tmp/rabbit-tls/server.crt
|
||||
ssl_options.keyfile = /tmp/rabbit-tls/server.key
|
||||
ssl_options.verify = verify_peer
|
||||
ssl_options.fail_if_no_peer_cert = true
|
||||
EOF
|
||||
chown rabbitmq:rabbitmq /tmp/rabbit-conf/rabbitmq.conf 2>/dev/null || true
|
||||
chmod 644 /tmp/rabbit-conf/rabbitmq.conf
|
||||
export RABBITMQ_CONFIG_FILE=/tmp/rabbit-conf/rabbitmq
|
||||
exec /usr/local/bin/docker-entrypoint.sh rabbitmq-server
|
||||
@@ -0,0 +1,21 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
mkdir -p /tls-run
|
||||
cp /tls/redis.crt /tls-run/redis.crt
|
||||
cp /tls/redis.key /tls-run/redis.key
|
||||
cp /tls/ca.crt /tls-run/ca.crt
|
||||
chmod 600 /tls-run/redis.key
|
||||
chmod 644 /tls-run/redis.crt /tls-run/ca.crt
|
||||
exec redis-server \
|
||||
--tls-port 6379 \
|
||||
--port 0 \
|
||||
--tls-cert-file /tls-run/redis.crt \
|
||||
--tls-key-file /tls-run/redis.key \
|
||||
--tls-ca-cert-file /tls-run/ca.crt \
|
||||
--tls-auth-clients no \
|
||||
--appendonly yes \
|
||||
--appendfsync everysec \
|
||||
--dir /data \
|
||||
--save 60 1 \
|
||||
--bind 0.0.0.0 \
|
||||
--protected-mode no
|
||||
@@ -0,0 +1,2 @@
|
||||
@echo off
|
||||
python -X utf8 "%~dp0restart.py" %*
|
||||
Executable → Regular
@@ -0,0 +1,26 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Windows-friendly persistence hook: restart stateful services, keep volumes."""
|
||||
from __future__ import annotations
|
||||
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
|
||||
def run(args: list[str]) -> None:
|
||||
subprocess.check_call(args, cwd=ROOT)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
run(["docker", "compose", "--env-file", ".env", "restart", "postgres", "redis", "minio", "rabbitmq", "prometheus", "loki", "tempo", "openbao"])
|
||||
run(["docker", "compose", "--env-file", ".env", "up", "-d", "--wait", "--no-deps", "postgres", "redis", "minio", "rabbitmq", "prometheus", "loki", "tempo", "openbao"])
|
||||
# OpenBao may be sealed after restart; operator unseal without printing keys.
|
||||
subprocess.call([sys.executable, "-X", "utf8", str(ROOT / "scripts" / "openbao_bootstrap.py")], cwd=ROOT, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
run(["docker", "compose", "--env-file", ".env", "restart", "api", "worker"])
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,10 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
# Рестарт API и хранилищ со состоянием. Volume не удаляем.
|
||||
# OpenBao после рестарта может быть sealed — оператор делает unseal отдельно.
|
||||
docker compose --env-file .env restart postgres redis minio rabbitmq prometheus loki tempo openbao
|
||||
docker compose --env-file .env up -d --wait --no-deps postgres redis minio rabbitmq prometheus loki tempo openbao
|
||||
# Если OpenBao sealed — unseal локальными ключами оператора (без печати).
|
||||
python -X utf8 scripts/openbao_bootstrap.py >/tmp/bao-restart.log 2>&1 || true
|
||||
docker compose --env-file .env restart api worker
|
||||
@@ -0,0 +1,2 @@
|
||||
@echo off
|
||||
python -X utf8 "%~dp0stop_one.py" %*
|
||||
Executable → Regular
@@ -0,0 +1,23 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?}"
|
||||
|
||||
found=""
|
||||
for id in $(docker ps -q \
|
||||
--filter label=com.docker.compose.project=mtusi-lab7 \
|
||||
--filter label=com.docker.compose.service=api); do
|
||||
host=$(docker inspect -f '{{.Config.Hostname}}' "$id")
|
||||
short=$(printf %s "$id" | cut -c1-12)
|
||||
if [ "$host" = "$TARGET_INSTANCE_ID" ] || [ "$short" = "$TARGET_INSTANCE_ID" ]; then
|
||||
found=$id
|
||||
break
|
||||
fi
|
||||
done
|
||||
|
||||
if [ -z "$found" ]; then
|
||||
echo "api replica not found" >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# SIGTERM, затем процесс остаётся остановленным (restart: unless-stopped).
|
||||
docker stop --time 5 "$found" >/dev/null
|
||||
@@ -0,0 +1,45 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Остановить одну API-реплику по TARGET_INSTANCE_ID (hostname контейнера)."""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
|
||||
def main() -> int:
|
||||
target = os.environ.get("TARGET_INSTANCE_ID", "").strip()
|
||||
if not target:
|
||||
print("TARGET_INSTANCE_ID required", file=sys.stderr)
|
||||
return 1
|
||||
out = subprocess.check_output(
|
||||
[
|
||||
"docker",
|
||||
"ps",
|
||||
"-q",
|
||||
"--filter",
|
||||
"label=com.docker.compose.project=mtusi-lab7",
|
||||
"--filter",
|
||||
"label=com.docker.compose.service=api",
|
||||
],
|
||||
text=True,
|
||||
)
|
||||
found = None
|
||||
for line in out.splitlines():
|
||||
cid = line.strip()
|
||||
if not cid:
|
||||
continue
|
||||
host = subprocess.check_output(["docker", "inspect", "-f", "{{.Config.Hostname}}", cid], text=True).strip()
|
||||
short = cid[:12]
|
||||
if host == target or short == target:
|
||||
found = cid
|
||||
break
|
||||
if not found:
|
||||
print("api replica not found", file=sys.stderr)
|
||||
return 1
|
||||
subprocess.check_call(["docker", "stop", "--time", "5", found], stdout=subprocess.DEVNULL)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,37 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Ждать GET /health/ready через HTTPS балансировщик. Без токенов в выводе."""
|
||||
import os
|
||||
import ssl
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
BASE = os.environ.get("BASE_URL", "https://127.0.0.1:8443").rstrip("/")
|
||||
URL = BASE + "/health/ready"
|
||||
CA = os.environ.get("CA_FILE") or str(ROOT / "certs" / "ca.crt")
|
||||
|
||||
|
||||
def main():
|
||||
context = ssl.create_default_context(cafile=CA)
|
||||
deadline = time.monotonic() + 120
|
||||
last = "not-started"
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
req = urllib.request.Request(URL)
|
||||
response = urllib.request.urlopen(req, timeout=2, context=context)
|
||||
if response.status == 200 and response.headers.get("X-Instance-Id"):
|
||||
print("ready")
|
||||
return 0
|
||||
last = str(response.status)
|
||||
except (urllib.error.URLError, TimeoutError, OSError) as exc:
|
||||
last = type(exc).__name__
|
||||
time.sleep(1)
|
||||
print("not ready: " + last, file=sys.stderr)
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
Reference in New Issue
Block a user