Lab7: HTTPS, mTLS, OpenBao, трек 2 PKI на оценку 5
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
Wladislava1
2026-11-17 00:25:48 +03:00
parent 20afc2c790
commit 54dcf70ea6
88 changed files with 8930 additions and 58 deletions
+100
View File
@@ -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())
+220
View File
@@ -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())
+30
View File
@@ -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"
+8
View File
@@ -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
+13
View File
@@ -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
+166
View File
@@ -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())
+28
View File
@@ -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())
+19
View File
@@ -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
+29
View File
@@ -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
+21
View File
@@ -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
+2
View File
@@ -0,0 +1,2 @@
@echo off
python -X utf8 "%~dp0restart.py" %*
Executable → Regular
View File
+26
View File
@@ -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())
+10
View File
@@ -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
+2
View File
@@ -0,0 +1,2 @@
@echo off
python -X utf8 "%~dp0stop_one.py" %*
Executable → Regular
View File
+23
View File
@@ -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
+45
View File
@@ -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())
+37
View File
@@ -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())