234 lines
10 KiB
Python
Executable File
234 lines
10 KiB
Python
Executable File
#!/usr/bin/env -S uv run --script
|
|
# /// script
|
|
# requires-python = ">=3.13"
|
|
# dependencies = [
|
|
# "authentik-client>=2026.8.5",
|
|
# "requests>=2.34.2",
|
|
# ]
|
|
# ///
|
|
"""Legt in authentik einen Deploy-User für ein Gitea-Repository an und hinterlegt
|
|
die Zugangsdaten als Gitea-Actions-Secrets/-Variablen."""
|
|
|
|
import argparse
|
|
import os
|
|
import re
|
|
import sys
|
|
from getpass import getpass
|
|
from pathlib import Path
|
|
from urllib.parse import urlparse
|
|
|
|
import authentik_client
|
|
import requests
|
|
from authentik_client.rest import ApiException
|
|
|
|
DEFAULT_AUTHENTIK_URL = "https://auth.share-fix.de/api/v3"
|
|
DEFAULT_GITEA_URL = "https://git.share-fix.de"
|
|
DEFAULT_SERVER = "H1"
|
|
HOME_DIR_BASE = "/home"
|
|
USERNAME_RE = re.compile(r"^[a-z_][a-z0-9_-]{0,31}$")
|
|
|
|
|
|
# ── Gitea ────────────────────────────────────────────────────────────────────
|
|
class Gitea:
|
|
def __init__(self, base_url: str, token: str):
|
|
self.base = base_url.rstrip("/") + "/api/v1"
|
|
self.session = requests.Session()
|
|
self.session.headers["Authorization"] = f"token {token}"
|
|
|
|
def _request(self, method: str, path: str, **kwargs):
|
|
response = self.session.request(method, self.base + path, timeout=30, **kwargs)
|
|
response.raise_for_status()
|
|
return response
|
|
|
|
def get_repo(self, repo_path: str) -> dict:
|
|
print(f"Retrieving repository {repo_path}")
|
|
return self._request("GET", f"/repos/{repo_path}").json()
|
|
|
|
def set_secret(self, repo_path: str, key: str, value: str):
|
|
print(f"Setting secret {key} for {repo_path}")
|
|
self._request("PUT", f"/repos/{repo_path}/actions/secrets/{key}", json={"data": value})
|
|
|
|
def set_variable(self, repo_path: str, key: str, value: str):
|
|
print(f"Setting variable {key} for {repo_path}")
|
|
url = f"/repos/{repo_path}/actions/variables/{key}"
|
|
try:
|
|
self._request("PUT", url, json={"value": value})
|
|
except requests.HTTPError as e:
|
|
if e.response is None or e.response.status_code != 404:
|
|
raise
|
|
self._request("POST", url, json={"value": value})
|
|
|
|
|
|
def normalize_repo_path(raw: str, gitea_url: str) -> str:
|
|
"""Akzeptiert 'owner/repo', Web-URLs und Clone-URLs (mit/ohne .git)."""
|
|
raw = raw.strip()
|
|
if raw.startswith(("http://", "https://")):
|
|
raw = urlparse(raw).path
|
|
raw = raw.strip("/").removesuffix(".git")
|
|
if raw.count("/") != 1:
|
|
raise ValueError(f"Repository muss die Form 'owner/repo' haben, bekam: '{raw}'")
|
|
return raw
|
|
|
|
|
|
# ── authentik ────────────────────────────────────────────────────────────────
|
|
def authentik_get_group_by_name(client: authentik_client.CoreApi, name: str):
|
|
groups = client.core_groups_list(search=name)
|
|
for group in groups.results or []:
|
|
if group.name == name:
|
|
print(f"{name} group found: uuid={group.pk}")
|
|
return group
|
|
raise RuntimeError(f"Gruppe '{name}' nicht gefunden")
|
|
|
|
|
|
def authentik_create_user(client: authentik_client.CoreApi, username: str, home_directory: str, groups, repo_url: str) -> str:
|
|
print(f"Creating user: {username}")
|
|
users = client.core_users_list(username=username)
|
|
if users.results:
|
|
print(f"User {username} already exists")
|
|
user = users.results[0]
|
|
client.core_users_partial_update(
|
|
id=user.pk,
|
|
patched_user_request=authentik_client.PatchedUserRequest(
|
|
attributes={**(user.attributes or {}), "notes": repo_url, "homeDirectory": home_directory}
|
|
),
|
|
)
|
|
else:
|
|
user = client.core_users_create(
|
|
user_request=authentik_client.UserRequest(
|
|
username=username,
|
|
name=username,
|
|
type=authentik_client.UserTypeEnum.SERVICE_ACCOUNT,
|
|
is_active=True,
|
|
path="goauthentik.io/service-accounts",
|
|
attributes={
|
|
"notes": repo_url,
|
|
"homeDirectory": home_directory,
|
|
"goauthentik.io/user/token-expires": False,
|
|
},
|
|
)
|
|
)
|
|
|
|
print(f"Adding user {username} to groups: {', '.join(g.name for g in groups)}")
|
|
for group in groups:
|
|
client.core_groups_add_user_create(
|
|
group_uuid=group.pk,
|
|
user_account_request=authentik_client.UserAccountRequest(pk=user.pk),
|
|
)
|
|
|
|
token_identifier = f"service-account-{username}-password"
|
|
if client.core_tokens_list(identifier=token_identifier).results:
|
|
print(f"Token {token_identifier} already exists")
|
|
else:
|
|
print(f"Creating token for user {username}")
|
|
client.core_tokens_create(
|
|
authentik_client.TokenRequest(
|
|
identifier=token_identifier,
|
|
user=user.pk,
|
|
intent=authentik_client.IntentEnum.APP_PASSWORD,
|
|
expiring=False,
|
|
)
|
|
)
|
|
return client.core_tokens_view_key_retrieve(token_identifier).key
|
|
|
|
|
|
# ── CLI ──────────────────────────────────────────────────────────────────────
|
|
def parse_args() -> argparse.Namespace:
|
|
p = argparse.ArgumentParser(description="Deploy-User für ein Gitea-Repository in authentik anlegen")
|
|
p.add_argument("--server", default=DEFAULT_SERVER,
|
|
help=f"Zielserver; bestimmt server_<SERVER>_ssh_access und server_<SERVER>_docker_compose (Standard: {DEFAULT_SERVER})")
|
|
p.add_argument("--project-path", help="Gitea-Repository: 'owner/repo' oder URL")
|
|
p.add_argument("--username", help="Username des Deploy-Users (Standard: deploy_<owner>_<repo>)")
|
|
p.add_argument("--docker-group",
|
|
help="Gruppe für Docker-Deploys (Standard: server_<SERVER>_docker_compose)")
|
|
p.add_argument("--no-docker-group", action="store_true", help="Docker-Deploy-Gruppe nicht zuweisen")
|
|
p.add_argument("--authentik-url", default=DEFAULT_AUTHENTIK_URL)
|
|
p.add_argument("--authentik-token", default=os.environ.get("AUTHENTIK_TOKEN"),
|
|
help="Bearer-Token für die authentik-API (oder Env AUTHENTIK_TOKEN)")
|
|
p.add_argument("--gitea-url", default=DEFAULT_GITEA_URL)
|
|
p.add_argument("--gitea-token", default=os.environ.get("GITEA_TOKEN"),
|
|
help="Gitea-Access-Token mit Scope write:repository (oder Env GITEA_TOKEN)")
|
|
p.add_argument("--dry-run", action="store_true", help="Nichts anlegen, nur ausgeben")
|
|
p.add_argument("-y", "--yes", action="store_true", help="Bestätigungsabfrage überspringen")
|
|
return p.parse_args()
|
|
|
|
|
|
def make_username(repo_path: str) -> str:
|
|
name = "deploy_" + re.sub(r"[^a-z0-9]+", "_", repo_path.lower()).strip("_")
|
|
return name[:32].rstrip("_")
|
|
|
|
|
|
def load_env_file(path: Path) -> None:
|
|
"""Liest KEY=VALUE-Zeilen aus einer .env; bereits gesetzte Variablen haben Vorrang."""
|
|
if not path.is_file():
|
|
return
|
|
for line in path.read_text().splitlines():
|
|
line = line.strip()
|
|
if not line or line.startswith("#") or "=" not in line:
|
|
continue
|
|
key, _, value = line.removeprefix("export ").partition("=")
|
|
os.environ.setdefault(key.strip(), value.strip().strip("\"'"))
|
|
|
|
|
|
def main() -> int:
|
|
load_env_file(Path(__file__).resolve().parent / ".env")
|
|
args = parse_args()
|
|
|
|
if not re.fullmatch(r"[A-Za-z0-9_-]+", args.server):
|
|
sys.exit(f"Ungültiger Servername: '{args.server}'")
|
|
if not args.dry_run and not args.authentik_token:
|
|
print(f"Authentik-API-Token erstellen unter {args.authentik_url.split('/api')[0]}/if/user/#/settings;page=page-tokens")
|
|
args.authentik_token = getpass("Enter authentik token: ")
|
|
if not args.gitea_token:
|
|
print(f"Gitea-Token erstellen unter {args.gitea_url}/user/settings/applications (Scope: write:repository)")
|
|
args.gitea_token = getpass("Enter gitea token: ")
|
|
if not args.project_path:
|
|
args.project_path = input("Enter Gitea repository (owner/repo): ")
|
|
|
|
gitea = Gitea(args.gitea_url, args.gitea_token)
|
|
repo_path = normalize_repo_path(args.project_path, args.gitea_url)
|
|
repo = gitea.get_repo(repo_path)
|
|
repo_path = repo["full_name"] # kanonische Schreibweise
|
|
|
|
username = args.username or make_username(repo_path)
|
|
if not USERNAME_RE.match(username):
|
|
sys.exit(f"Ungültiger Username '{username}' (erlaubt: ^[a-z_][a-z0-9_-]{{0,31}}$)")
|
|
home_dir = f"{HOME_DIR_BASE}/{username}"
|
|
|
|
group_names = [f"server_{args.server}_ssh_access"]
|
|
if not args.no_docker_group:
|
|
group_names.append(args.docker_group or f"server_{args.server}_docker_compose")
|
|
|
|
print(f"\nRepository: {repo_path} (id {repo['id']})")
|
|
print(f"Deploy-User: {username}")
|
|
print(f"Home-Verz.: {home_dir}")
|
|
print(f"Gruppen: {', '.join(group_names)}")
|
|
print(f"Notes: {repo['html_url']}")
|
|
print(f"Gitea-Secrets: deploy_user, deploy_pass")
|
|
if args.dry_run:
|
|
print("\n[dry-run] Es wurde nichts angelegt.")
|
|
return 0
|
|
if not args.yes and input("\nBestätigen? Fortfahren? [y/N] ").lower() != "y":
|
|
return 0
|
|
|
|
configuration = authentik_client.Configuration(host=args.authentik_url, access_token=args.authentik_token)
|
|
with authentik_client.ApiClient(configuration) as api_client:
|
|
core_api = authentik_client.CoreApi(api_client)
|
|
try:
|
|
groups = [authentik_get_group_by_name(core_api, n) for n in group_names]
|
|
key = authentik_create_user(core_api, username, home_dir, groups, repo["html_url"])
|
|
except (ApiException, RuntimeError) as e:
|
|
sys.exit(f"Fehler in authentik: {e}")
|
|
|
|
try:
|
|
gitea.set_variable(repo_path, "deploy_user", username)
|
|
gitea.set_secret(repo_path, "deploy_pass", key)
|
|
except requests.RequestException as e:
|
|
sys.exit(f"Fehler in Gitea: {e}")
|
|
|
|
print(f"\nFertig: {username} für {repo_path}")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|