Files
homelab-infra/ansible/roles/rus-central/netbird/files/sync_access.py
T

340 lines
13 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Идемпотентная синхронизация клиентских групп, Exit Nodes, DNS, setup-ключей и пиров NetBird."""
import json
import os
import subprocess
import sys
from typing import Any
class NetBirdAPI:
"""Минимальный клиент NetBird API через curl с --resolve на 127.0.0.1."""
def __init__(self, domain: str, token: str) -> None:
self.domain = domain
self.base_url = f"https://{domain}/api"
self.token = token
def request(
self,
method: str,
path: str,
payload: dict[str, Any] | None = None,
) -> Any:
cmd = [
"curl",
"-sSk",
"--resolve",
f"{self.domain}:443:127.0.0.1",
"-w",
"\n%{http_code}",
"-X",
method,
f"{self.base_url}{path}",
"-H",
f"Authorization: Token {self.token}",
]
stdin_bytes = None
if payload is not None:
cmd.extend(["-H", "Content-Type: application/json", "--data-binary", "@-"])
stdin_bytes = json.dumps(payload, ensure_ascii=False).encode("utf-8")
proc = subprocess.run(cmd, input=stdin_bytes, capture_output=True, check=False)
if proc.returncode != 0:
raise RuntimeError(
f"curl error for {method} {path}: {proc.stderr.decode(errors='replace')}"
)
raw = proc.stdout.decode("utf-8", errors="replace")
body, _, code = raw.rpartition("\n")
code = code.strip()
if code not in ("200", "201", "204"):
raise RuntimeError(f"NetBird API {method} {path} returned HTTP {code}: {body}")
if not body.strip():
return None
return json.loads(body)
def get(self, path: str) -> Any:
return self.request("GET", path)
def post(self, path: str, payload: dict[str, Any]) -> Any:
return self.request("POST", path, payload)
def put(self, path: str, payload: dict[str, Any]) -> Any:
return self.request("PUT", path, payload)
def delete(self, path: str) -> Any:
return self.request("DELETE", path)
def group_peer_ids(grp: dict[str, Any]) -> list[str]:
return [p["id"] for p in (grp.get("peers") or []) if p.get("id")]
def sync(cfg: dict[str, Any], api: NetBirdAPI) -> dict[str, Any]:
changes: list[str] = []
warnings: list[str] = []
updated_secrets: dict[str, str] = {}
peers_raw = api.get("/peers") or []
groups_raw = api.get("/groups") or []
groups_by_name: dict[str, dict[str, Any]] = {g["name"]: g for g in groups_raw if g.get("name")}
peers_by_name: dict[str, dict[str, Any]] = {}
for p in peers_raw:
if p.get("name"):
peers_by_name[p["name"]] = p
if p.get("hostname"):
peers_by_name.setdefault(p["hostname"], p)
def ensure_group(name: str) -> dict[str, Any]:
if name in groups_by_name:
return groups_by_name[name]
created = api.post("/groups", {"name": name, "peers": []})
groups_by_name[name] = created
changes.append(f"group.create:{name}")
return created
def set_group_peers(grp: dict[str, Any], new_ids: list[str]) -> None:
unique_ids = sorted(set(new_ids))
payload: dict[str, Any] = {"name": grp["name"], "peers": unique_ids}
if grp.get("resources"):
payload["resources"] = [
{"id": r["id"], "type": r["type"]}
for r in grp["resources"]
if r.get("id") and r.get("type")
]
updated = api.put(f"/groups/{grp['id']}", payload)
if isinstance(updated, dict) and updated.get("id"):
groups_by_name[grp["name"]] = updated
else:
grp["peers"] = [{"id": pid} for pid in unique_ids]
groups_by_name[grp["name"]] = grp
# 1. Группы клиентов
managed_client_groups: set[str] = set()
for gname in cfg.get("client_groups") or []:
ensure_group(gname)
managed_client_groups.add(gname)
# 2. Управление пирами
for item in cfg.get("peers") or []:
pname = item["name"]
state = item.get("state", "present")
peer = peers_by_name.get(pname)
if state == "absent":
if peer is not None:
api.delete(f"/peers/{peer['id']}")
changes.append(f"peer.delete:{pname}")
peers_by_name = {k: v for k, v in peers_by_name.items() if v.get("id") != peer["id"]}
for grp in groups_by_name.values():
if grp.get("peers"):
grp["peers"] = [p for p in grp["peers"] if p.get("id") != peer["id"]]
continue
desired_groups = set(item.get("groups") or [])
for gname in desired_groups:
ensure_group(gname)
if peer is None:
warnings.append(f"peer not found yet: {pname}")
continue
pid = peer["id"]
for gname in sorted(desired_groups):
grp = groups_by_name[gname]
current_ids = group_peer_ids(grp)
if pid not in current_ids:
set_group_peers(grp, current_ids + [pid])
changes.append(f"group.add_peer:{gname}:{pname}")
for gname in sorted(managed_client_groups - desired_groups):
if gname not in groups_by_name:
continue
grp = groups_by_name[gname]
current_ids = group_peer_ids(grp)
if pid in current_ids:
set_group_peers(grp, [x for x in current_ids if x != pid])
changes.append(f"group.remove_peer:{gname}:{pname}")
# 3. Выходные шлюзы (Exit Nodes)
routes_raw = api.get("/routes") or []
for item in cfg.get("exit_nodes") or []:
net_id = item["network_id"]
peer_name = item.get("peer", "")
peer_group_name = item["peer_group"]
client_group_names = item.get("client_groups") or []
peer_grp = ensure_group(peer_group_name)
if peer_name and peer_name in peers_by_name:
pid = peers_by_name[peer_name]["id"]
current_ids = group_peer_ids(peer_grp)
if pid not in current_ids:
set_group_peers(peer_grp, current_ids + [pid])
changes.append(f"group.add_peer:{peer_group_name}:{peer_name}")
client_group_ids = [ensure_group(g)["id"] for g in client_group_names]
peer_group_ids = [groups_by_name[peer_group_name]["id"]]
desired = {
"description": item.get("description", f"Exit Node ({net_id})"),
"network_id": net_id,
"enabled": bool(item.get("enabled", True)),
"peer_groups": peer_group_ids,
"network": "0.0.0.0/0",
"metric": int(item.get("metric", 100)),
"masquerade": bool(item.get("masquerade", True)),
"groups": client_group_ids,
"keep_route": bool(item.get("keep_route", True)),
"skip_auto_apply": bool(item.get("skip_auto_apply", False)),
}
existing = next(
(r for r in routes_raw if r.get("network_id") == net_id and r.get("network") == "0.0.0.0/0"),
None,
)
if existing is None:
if not group_peer_ids(groups_by_name[peer_group_name]):
warnings.append(f"exit_node {net_id}: no peers in {peer_group_name} yet")
continue
api.post("/routes", desired)
changes.append(f"route.create:{net_id}")
else:
needs_update = (
(existing.get("description") or "") != desired["description"]
or bool(existing.get("enabled")) != desired["enabled"]
or int(existing.get("metric", 100)) != desired["metric"]
or bool(existing.get("masquerade")) != desired["masquerade"]
or bool(existing.get("keep_route")) != desired["keep_route"]
or bool(existing.get("skip_auto_apply")) != desired["skip_auto_apply"]
or sorted(existing.get("peer_groups") or []) != sorted(desired["peer_groups"])
or sorted(existing.get("groups") or []) != sorted(desired["groups"])
)
if needs_update:
api.put(f"/routes/{existing['id']}", desired)
changes.append(f"route.update:{net_id}")
# 4. DNS Nameservers
ns_raw = api.get("/dns/nameservers") or []
for item in cfg.get("dns_nameservers") or []:
name = item["name"]
existing = next((n for n in ns_raw if n.get("name") == name), None)
if not bool(item.get("enabled", True)):
if existing is not None:
api.delete(f"/dns/nameservers/{existing['id']}")
changes.append(f"dns.delete:{name}")
continue
group_ids = [ensure_group(g)["id"] for g in (item.get("groups") or [])]
desired = {
"name": name,
"description": item.get("description", ""),
"nameservers": [
{"ip": s, "ns_type": "udp", "port": 53}
for s in (item.get("servers") or [])
],
"enabled": True,
"groups": group_ids,
"primary": bool(item.get("primary", True)),
"domains": item.get("domains") or [],
"search_domains_enabled": bool(item.get("search_domains_enabled", False)),
}
if existing is None:
api.post("/dns/nameservers", desired)
changes.append(f"dns.create:{name}")
else:
needs_update = (
(existing.get("description") or "") != desired["description"]
or (existing.get("nameservers") or []) != desired["nameservers"]
or bool(existing.get("enabled")) != desired["enabled"]
or sorted(existing.get("groups") or []) != sorted(desired["groups"])
or bool(existing.get("primary")) != desired["primary"]
or (existing.get("domains") or []) != desired["domains"]
or bool(existing.get("search_domains_enabled")) != desired["search_domains_enabled"]
)
if needs_update:
api.put(f"/dns/nameservers/{existing['id']}", desired)
changes.append(f"dns.update:{name}")
# 5. Setup-ключи клиентов
keys_raw = api.get("/setup-keys") or []
for item in cfg.get("setup_keys") or []:
name = item["name"]
secret_var = item["secret"]
enabled = bool(item.get("enabled", True))
matching = [k for k in keys_raw if k.get("name") == name]
if not enabled:
for k in matching:
api.delete(f"/setup-keys/{k['id']}")
changes.append(f"setup_key.delete:{name}")
continue
group_ids = [ensure_group(g)["id"] for g in (item.get("groups") or [])]
env_present = bool(os.environ.get(secret_var, ""))
valid_match = next(
(
k
for k in matching
if k.get("valid") is True
and k.get("revoked") is False
and sorted(k.get("auto_groups") or []) == sorted(group_ids)
),
None,
)
if valid_match is not None and env_present:
continue
for k in matching:
api.delete(f"/setup-keys/{k['id']}")
key_payload = {
"name": name,
"type": item.get("type", "reusable"),
"expires_in": int(item.get("expires_in", 31536000)),
"revoked": False,
"auto_groups": group_ids,
"usage_limit": int(item.get("usage_limit", 0)),
"ephemeral": bool(item.get("ephemeral", False)),
}
created_key = api.post("/setup-keys", key_payload)
plain_key = (created_key or {}).get("key", "")
if not plain_key:
raise RuntimeError(f"NetBird API did not return key for setup_key {name}")
updated_secrets[secret_var] = plain_key
changes.append(f"setup_key.reissue:{name}")
return {
"changed": bool(changes or updated_secrets),
"changes": changes,
"warnings": warnings,
"updated_secret_names": sorted(updated_secrets.keys()),
"updated_secrets": updated_secrets,
}
def main() -> None:
if len(sys.argv) < 2:
raise SystemExit("Usage: sync_access.py <access.json>")
domain = os.environ.get("NB_DOMAIN", "")
token = os.environ.get("NB_API_TOKEN", "")
if not domain or not token:
raise SystemExit("NB_DOMAIN and NB_API_TOKEN are required")
with open(sys.argv[1], "r", encoding="utf-8") as fh:
cfg = json.load(fh)
api = NetBirdAPI(domain=domain, token=token)
result = sync(cfg, api)
sys.stdout.write(json.dumps(result, ensure_ascii=False) + "\n")
if __name__ == "__main__":
main()