Deployment-Setup (PostgreSQL+nginx-Installer) + Sprint-0-Fixes aus Subagenten-Reviews

Installer (deploy/):
- install_server.sh: PostgreSQL+nginx auf Debian 13, idempotente Rolle/DB-Anlage,
  pgcrypto-Extension, Speicher-Tuning für 4GB-VPS, Zugangsdaten in chmod-600-Datei
  statt stdout (postgres-expert/owasp-Review)
- nginx-Template mit Security-Headern + Rate-Limit auf /auth/login
- systemd-Unit-Template mit Sandboxing (NoNewPrivileges/ProtectSystem/PrivateTmp)

Backend-Fixes (fastapi-expert-Review):
- get_db: einheitliche commit/rollback-Konvention statt Endpunkt-Copy-Paste
- Test-Fixtures auf SQLAlchemy-2.0-Savepoint-Pattern umgestellt (join_transaction_mode),
  da get_db jetzt selbst committet
- Lifespan-Handler: Startup-Guard gegen JWT-Secret-Platzhalter, engine.dispose() beim Shutdown
- JWT-Payload ohne ungenutztes roles-Claim (Rollen kommen immer frisch aus der DB)

Zusätzlich: Subagenten-Definitionen (~/.claude/agents/) auf lauffähiges Modell fixiert.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01L85hmKbvX7Cqkq47KnQhFt

backend/app/api/v1/endpoints/auth.py

@@ -41,7 +41,7 @@ async def login(
             detail="Login oder Passwort falsch",
             headers={"WWW-Authenticate": "Bearer"},
         )
-    token = create_access_token(subject=benutzer.login, roles=benutzer.rollen_namen)
+    token = create_access_token(subject=benutzer.login)
     return TokenResponse(access_token=token)
 
 

backend/app/core/security.py

@@ -16,9 +16,11 @@ def verify_password(plain_password: str, password_hash: str) -> bool:
     return _pwd_context.verify(plain_password, password_hash)
 
 
-def create_access_token(*, subject: str, roles: list[str]) -> str:
+def create_access_token(*, subject: str) -> str:
+    # Bewusst KEINE Rollen im Token: get_current_user liest Rollen bei jedem Request
+    # frisch aus der DB (Rollenänderung wirkt sofort, kein Token-Refresh nötig).
     expire = datetime.now(timezone.utc) + timedelta(minutes=settings.access_token_expire_minutes)
-    payload = {"sub": subject, "roles": roles, "exp": expire}
+    payload = {"sub": subject, "exp": expire}
     return jwt.encode(payload, settings.jwt_secret_key, algorithm=settings.jwt_algorithm)
 
 

backend/app/db/session.py

@@ -9,5 +9,16 @@ SessionLocal = async_sessionmaker(engine, expire_on_commit=False)
 
 
 async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """Konvention für alle Endpunkte: Erfolg -> commit, Exception -> rollback.
+
+    Endpunkte selbst rufen kein `db.commit()`/`db.rollback()` auf, sondern verlassen
+    sich auf diese Dependency (Review-Fund: Konvention muss zentral, nicht pro
+    Endpunkt copy-paste sein).
+    """
     async with SessionLocal() as session:
-        yield session
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise

backend/app/main.py

@@ -1,6 +1,24 @@
+from contextlib import asynccontextmanager
+
 from fastapi import FastAPI
 
 from app.api.v1.api import api_router
+from app.core.app_settings import settings
+from app.db.session import engine
 
-app = FastAPI(title="MABEA", version="0.1.0")
+_PLACEHOLDER_JWT_SECRET = "change-me-to-a-long-random-value"
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    if not settings.jwt_secret_key or settings.jwt_secret_key == _PLACEHOLDER_JWT_SECRET:
+        raise RuntimeError(
+            "JWT_SECRET_KEY ist leer oder noch der Platzhalter aus example.env – "
+            "in .env auf dem Zielsystem einen echten zufälligen Wert setzen."
+        )
+    yield
+    await engine.dispose()
+
+
+app = FastAPI(title="MABEA", version="0.1.0", lifespan=lifespan)
 app.include_router(api_router, prefix="/api/v1")

backend/tests/conftest.py

@@ -18,14 +18,26 @@ TestSessionLocal = async_sessionmaker(engine, expire_on_commit=False)
 
 @pytest_asyncio.fixture
 async def db_session():
+    """Jeder Test läuft in einer äußeren Transaktion, die am Ende zurückgerollt wird.
+
+    Die Session ist per `join_transaction_mode="create_savepoint"` an die äußere
+    Connection gebunden: ein `commit()` innerhalb des Tests (z. B. durch `get_db`,
+    das jetzt selbst committet) schließt nur eine SAVEPOINT ab, nicht die äußere
+    Transaktion – das äußere `connection.rollback()` verwirft am Ende trotzdem alles.
+    (SQLAlchemy 2.0 "Joining a Session into an External Transaction" – Review-Fund
+    fastapi-expert: ohne dieses Pattern hätte ein commit() in Endpunkten die
+    Testisolation gebrochen.)
+    """
     async with engine.connect() as connection:
-        transaction = await connection.begin()
-        session = AsyncSession(bind=connection, expire_on_commit=False)
+        await connection.begin()
+        session = AsyncSession(
+            bind=connection, expire_on_commit=False, join_transaction_mode="create_savepoint"
+        )
         try:
             yield session
         finally:
             await session.close()
-            await transaction.rollback()
+            await connection.rollback()
 
 
 @pytest_asyncio.fixture