Files
homelab-infra/ansible/roles/rus-central/netbird/files/sync_access.py
T
karpenokandCursor 99ee815213
ansible-deploy / plan (push) Successful in 1s
ansible-lint / lint (push) Successful in 2s
ansible-deploy / deploy (core-mon, ) (push) Successful in 37s
ansible-deploy / deploy (core-net, ) (push) Failing after 52s
ansible-deploy / deploy (core-secrets, ) (push) Successful in 24s
ansible-deploy / deploy (ger-nod-02, ) (push) Successful in 1m20s
ansible-deploy / deploy (opnsense, ) (push) Successful in 13s
ansible-deploy / deploy (rus-central, ) (push) Successful in 1m6s
refactor(remnawave): синхронизировать панель из desired.yml и шаблонов команд
Повторный прогон без смены compose не тянет образы, ноды и сквады добавляются данными, а не новым плейбуком на каждый VPS.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-18 17:18:49 +07:00

487 lines
19 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 expand_remnawave(cfg: dict[str, Any]) -> None:
"""Группы, exit-маршруты и пиры нод берутся из desired.yml, не копируются руками."""
if "remnawave_nodes" not in cfg:
return
nodes = cfg.pop("remnawave_nodes") or []
groups: list[str] = []
for node in nodes:
host = str(node.get("netbird_hostname") or "").strip()
if not host:
continue
group = f"exit-{host}"
groups.append(group)
client_groups = cfg.setdefault("client_groups", [])
if group not in client_groups:
client_groups.append(group)
exits = cfg.setdefault("exit_nodes", [])
if not any(item.get("network_id") == group for item in exits):
code = str(node.get("country_code") or "").strip()
exits.append(
{
"network_id": group,
"description": f"Exit Node {code} via {host}".strip(),
"peer": host,
"peer_group": group,
"client_groups": ["exit-clients"],
"metric": 9999,
"masquerade": True,
"keep_route": False,
"skip_auto_apply": False,
"enabled": True,
}
)
peers = cfg.setdefault("peers", [])
if not any(item.get("name") == host for item in peers):
peers.append({"name": host, "groups": [group], "state": "present"})
cfg["_remnawave_exit_groups"] = groups
for policy in cfg.get("policies") or []:
for rule in policy.get("rules") or []:
dest = rule.get("destinations")
if dest == "@remnawave_exit_groups":
rule["destinations"] = list(groups)
elif isinstance(dest, list) and "@remnawave_exit_groups" in dest:
expanded: list[str] = []
for item in dest:
expanded.extend(groups if item == "@remnawave_exit_groups" else [item])
rule["destinations"] = expanded
def sync(cfg: dict[str, Any], api: NetBirdAPI) -> dict[str, Any]:
changes: list[str] = []
warnings: list[str] = []
updated_secrets: dict[str, str] = {}
expand_remnawave(cfg)
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}")
keep_exit_groups = cfg.get("_remnawave_exit_groups")
if keep_exit_groups is not None:
keep = set(keep_exit_groups)
for route in routes_raw:
net_id = str(route.get("network_id") or "")
if route.get("network") == "0.0.0.0/0" and net_id.startswith("exit-") and net_id not in keep and route.get("id"):
api.delete(f"/routes/{route['id']}")
changes.append(f"route.delete:{net_id}")
for gname, grp in list(groups_by_name.items()):
if not gname.startswith("exit-") or gname == "exit-clients" or gname in keep:
continue
current_ids = group_peer_ids(grp)
if current_ids:
set_group_peers(grp, [])
changes.append(f"group.clear:{gname}")
# 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}")
# 6. Политики доступа (Zero-Trust ACL)
if "policies" in cfg:
policies_raw = api.get("/policies") or []
existing_by_name = {p.get("name"): p for p in policies_raw if p.get("name")}
desired_policy_names: set[str] = set()
def _extract_group_ids(items: list[Any]) -> list[str]:
out: list[str] = []
for x in items or []:
if isinstance(x, dict) and x.get("id"):
out.append(str(x["id"]))
elif isinstance(x, str):
out.append(x)
return sorted(out)
for p_cfg in cfg.get("policies") or []:
p_name = p_cfg["name"]
desired_policy_names.add(p_name)
rules_payload: list[dict[str, Any]] = []
for r_cfg in p_cfg.get("rules") or []:
src_ids = sorted(ensure_group(g)["id"] for g in (r_cfg.get("sources") or []))
dst_ids = sorted(ensure_group(g)["id"] for g in (r_cfg.get("destinations") or []))
rule_obj: dict[str, Any] = {
"name": r_cfg["name"],
"description": r_cfg.get("description", ""),
"enabled": bool(r_cfg.get("enabled", True)),
"action": r_cfg.get("action", "accept"),
"protocol": r_cfg.get("protocol", "tcp"),
"bidirectional": bool(r_cfg.get("bidirectional", False)),
"sources": src_ids,
"destinations": dst_ids,
}
if r_cfg.get("ports"):
rule_obj["ports"] = [str(p) for p in r_cfg["ports"]]
rules_payload.append(rule_obj)
desired_pol = {
"name": p_name,
"description": p_cfg.get("description", ""),
"enabled": bool(p_cfg.get("enabled", True)),
"rules": rules_payload,
}
ex_pol = existing_by_name.get(p_name)
if ex_pol is None:
api.post("/policies", desired_pol)
changes.append(f"policy.create:{p_name}")
else:
ex_rules = ex_pol.get("rules") or []
norm_ex_rules = [
{
"name": r.get("name", ""),
"description": r.get("description", ""),
"enabled": bool(r.get("enabled", True)),
"action": r.get("action", "accept"),
"protocol": r.get("protocol", "tcp"),
"bidirectional": bool(r.get("bidirectional", False)),
"sources": _extract_group_ids(r.get("sources") or []),
"destinations": _extract_group_ids(r.get("destinations") or []),
**(
{"ports": [str(p) for p in r["ports"]]}
if r.get("ports")
else {}
),
}
for r in ex_rules
]
needs_pol_update = (
(ex_pol.get("description") or "") != desired_pol["description"]
or bool(ex_pol.get("enabled", True)) != desired_pol["enabled"]
or norm_ex_rules != rules_payload
)
if needs_pol_update:
api.put(f"/policies/{ex_pol['id']}", desired_pol)
changes.append(f"policy.update:{p_name}")
# Удаляем дефолтную (All <-> All) и любые лишние политики после создания целевых
for ex_name, ex_pol in existing_by_name.items():
if ex_name not in desired_policy_names and ex_pol.get("id"):
api.delete(f"/policies/{ex_pol['id']}")
changes.append(f"policy.delete:{ex_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()