340 lines
13 KiB
Python
340 lines
13 KiB
Python
#!/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()
|