BIRD-Config nach Ansible (ffc-mash) auslagern

README.md

@@ -56,16 +56,15 @@ Ist ein Routing Deamon zur Verbindung mit anderen Netzen.
 # aptitude install bird
 ```
 
-Wenn sys-V-init verwendet wird:
-```
-# update-rc.d bird disable
-# update-rc.d bird6 disable
-```
+Die BIRD-/BIRD6-Konfiguration (`/etc/bird/bird.conf`, `/etc/bird/bird6.conf`,
+`/etc/bird/bird-routes.country.conf`) und die `bird`/`bird6`-Dienste werden vom
+Ansible-Playbook [ffc-mash](https://github.com/FreifunkChemnitz/ffc-mash) verwaltet
+(Rolle `ffc_vpn_gateway`), nicht von diesen Skripten. `lib/bird.sh` / `lib/bird6.sh`
+richten nur noch das Policy-Routing (Tabelle 100) und NAT ein.
 
-Wenn systemd verwendet wird:
 ```
-# systemctl disable bird
-# systemctl disable bird6
+# systemctl enable bird
+# systemctl enable bird6
 ```
 
 
@@ -136,19 +135,18 @@ Wenn systemd verwendet wird:
 
 ```
 cd /opt/freifunk/server-scripts/conf
-cp bird.conf bird.local.conf
-cp bird-routes.conf bird-routes.local.conf
 cp dnsmasq.conf dnsmasq.local.conf
 cp general.conf general.local.conf
-touch bird-routes.local.conf
 ```
 
-#### bird.local.conf
-In der `bird.local.conf` muss `__BIRD_ROUTER_ID__` angepasst werden. Es ist mit mit 169.254.x.y zu ersetzen, wobei x das 3. Oktet und y das 4. Oktet der öffentlichen IPv4 des Servers sind. Wenn der Server die öffentliche IPv4 5.199.142.119 hat, wäre das 169.254.142.119.
-
-`__BIRD_ROUTER_ASN__` muss durch das 3. und 4. Oktet der öffentlichen IPv4 ersetzt werden, wobei der Punkt wegzulassen ist. Zum Beispiel wird aus 5.199.142.119 dann 142119.
+#### BIRD / BGP
 
-Auf Servern, die für das Chemnitzer Umland bestimmt sind ist das `route` unter `protocol static` anzupassen. Es muss auf `10.149.16.0/20` geändert werden.
+Die BIRD-Konfiguration wird nicht mehr hier gepflegt, sondern vom Ansible-Playbook
+[ffc-mash](https://github.com/FreifunkChemnitz/ffc-mash) (Rolle `ffc_vpn_gateway`)
+nach `/etc/bird/` gerendert – inklusive Router-ID/ASN (aus der öffentlichen IPv4),
+BGP-Peers, Mesh-Route (Umland: `ffc_vpn_gateway_bird_mesh_route_v4: 10.149.16.0/20`)
+und der statischen Länder-/Ausnahmerouten. `lib/bird.sh` richtet nur noch
+Policy-Routing (Tabelle 100) und NAT ein.
 
 #### dnsmasq.local.conf
 
@@ -173,8 +171,9 @@ USE_RADVD="0"
 USE_MESHVIEWER="0"
 ```
 
-`COUNTRY` ist auf den 2 stelligen ISO-Code des Landes zu ändern, in dem der Server betrieben wird. Er wählt die passende Datei `conf/routes/<COUNTRY>.conf` mit den länderspezifischen Ausnahmerouten aus (zusätzlich zu `conf/routes/_global.conf`). Existiert keine solche Datei, werden nur die globalen Routen gerendert.
-`WANGW` ist das IPv4 Gateway des Server (`ip route show`). Über dieses Gateway werden die Ausnahmerouten aus `conf/routes/` geroutet (Platzhalter `NEXTHOP`). Ist `WANGW` leer, bleibt `conf/bird-routes.country.conf` leer.
+Das Land des Servers (früher `COUNTRY`) und die Länder-/Ausnahmerouten werden jetzt
+im ffc-mash-Playbook gepflegt (`ffc_vpn_gateway_country`,
+`roles/custom/ffc_vpn_gateway/files/bird-routes/`).
 
 `GRE_PEERS`, `LOG_DEBUG`, `LOG_TO` sollte gelöscht werden.
 

conf/.gitignore

@@ -1,2 +1 @@
 /*.local.*
-/bird-routes.country.conf

conf/general.conf

@@ -19,8 +19,6 @@ BATMAN_IFS=("gre-brewster" "gre-spooner" "gre-hawking" "gre-noether")
 LOG_DEBUG="0"
 LOG_TO="[email protected]"
 
-# Static country/exception routes for BIRD (see conf/routes/).
-# COUNTRY selects conf/routes/<COUNTRY>.conf; WANGW is the local WAN gateway
-# that these routes are sent via (NEXTHOP placeholder).
-COUNTRY="DE"
-WANGW=""
+# BIRD/BGP daemon config (incl. the static country/exception routes) is managed by
+# the ffc-mash Ansible playbook (ffc_vpn_gateway role), not by these scripts.
+# USE_BIRD above only toggles the kernel policy routing / NAT in lib/bird.sh.

docs/architektur.md

@@ -14,8 +14,7 @@ und per Cron überwacht werden.
 | `ffc-server.sh` | Zentrales Steuerskript: `start`, `stop`, `watchdog`. Lädt Konfiguration und alle `lib/*.sh`-Module. |
 | `initd-ffc.sh` | Dünner Wrapper, der `ffc-server.sh` als `/etc/init.d/ffc` einbindet (SysV-Init). |
 | `lib/*.sh` | Ein Modul pro Dienst/Funktion (siehe unten). Jedes Modul stellt `<name>_init`, `<name>_start`, `<name>_stop` und optional `<name>_cron` bereit. |
-| `conf/*.conf` | Eingecheckte Vorlagen/Defaults. Pro Server werden daraus `*.local.conf`-Dateien erzeugt bzw. von Hand angelegt (siehe `conf/.gitignore`: `*.local.*` und `bird-routes.country.conf` sind lokal/generiert und nicht versioniert). |
-| `conf/routes/*.conf` | Statisch gepflegte BIRD-Ausnahme-/Länderrouten (`_global.conf` + `<COUNTRY>.conf`), die `bird_init` zu `conf/bird-routes.country.conf` rendert. |
+| `conf/*.conf` | Eingecheckte Vorlagen/Defaults. Pro Server werden daraus `*.local.conf`-Dateien erzeugt bzw. von Hand angelegt (siehe `conf/.gitignore`: `*.local.*` ist lokal/generiert und nicht versioniert). Die BIRD-Konfiguration liegt **nicht** mehr hier, sondern im Ansible-Playbook [ffc-mash](https://github.com/FreifunkChemnitz/ffc-mash) (Rolle `ffc_vpn_gateway`, Ziel `/etc/bird/`). |
 
 ## Die Module in `lib/`
 
@@ -28,9 +27,9 @@ ihrem Zweck findet sich in [Komponenten](komponenten.md).
 | `gre.sh` | Aufbau der GRE-Tunnel (`gretap`) zu allen anderen Backbone-Servern aus `GRE_PEERS`; Watchdog-Check per ICMPv6-Ping auf die Tunnel-Interfaces. |
 | `batman.sh` | Initialisiert `batman-adv`, hängt die GRE-Interfaces (aus `BATMAN_IFS`) und später `fastd`-Interfaces als Slaves ein, konfiguriert `bat0` (Service-Adressen, Bridge-Loop-Avoidance, Bonding, Gateway-Modus) und startet `alfred`/`batadv-vis` für die Meshviewer-Daten. |
 | `fastd.sh` | Startet das fastd-VPN (einen Prozess pro CPU-Kern, jeweils auf eigenem Port), über das sich Freifunk-Router mit dem Server verbinden. |
-| `bird.sh` / `bird6.sh` | Generieren die BIRD-/BIRD6-Konfiguration aus Templates (`conf/bird*.conf`), tragen alle GRE-Peers als BGP-Nachbarn ein, setzen Policy-Routing (`ip rule`/`ip -6 rule`) für das Mesh-Netz und starten die Routing-Daemons. |
+| `bird.sh` / `bird6.sh` | Setzen das Policy-Routing (`ip rule`/`ip -6 rule` → Tabelle 100) und NAT für das Mesh-Netz und starten/stoppen die `bird`/`bird6`-Dienste (via systemd). Die BIRD-Konfiguration selbst (Router-ID, BGP-Peers, Routen) wird vom Ansible-Playbook [ffc-mash](https://github.com/FreifunkChemnitz/ffc-mash) (Rolle `ffc_vpn_gateway`) nach `/etc/bird/` gerendert. |
 | `dnsmasq.sh` | DHCP/DNS für Endgeräte im Mesh (`bat0`), optional, nur auf Servern mit `USE_DNSMASQ=1`. |
-| `radvd.sh` | IPv6 Router Advertisements für `bat0`, nur auf IPv6-Gateway-Servern (`USE_RADVD=1`), setzt zusätzlich eine Default-Route in BIRD6. |
+| `radvd.sh` | IPv6 Router Advertisements für `bat0`, nur auf IPv6-Gateway-Servern (`USE_RADVD=1`). Die zugehörige IPv6-Default-Route in BIRD6 kommt aus der Ansible-Rolle (`ffc_vpn_gateway_bird_ipv6_uplink`). |
 | `meshviewer.sh` | Startet `alfred`/`batadv-vis` unabhängig von `batman.sh`, falls der Server primär als Meshviewer-Datenquelle dient. |
 
 ## Ablauf: Start, Stop, Watchdog
@@ -74,27 +73,27 @@ Wichtige Details zum Ablauf:
 - **Watchdog:** `ffc-server.sh watchdog` wird minütlich per Cron aufgerufen (siehe README).
   Jede Minute werden laufende Prozesse (dnsmasq, radvd, alfred) geprüft und bei Bedarf neu
   gestartet; alle 5 Minuten wird zusätzlich die Erreichbarkeit der GRE-Tunnel per Ping
-  geprüft und die länderspezifische Routen-Datei von der Freifunk-Chemnitz-API neu geladen.
-  Fehler werden über `log_error`/`log_fatal_error` sowohl nach syslog als auch (im
+  geprüft. Fehler werden über `log_error`/`log_fatal_error` sowohl nach syslog als auch (im
   Watchdog-Kontext) per Mail an `LOG_TO` gemeldet.
-- **Konfigurations-Templating:** `bird.sh`, `bird6.sh` und `dnsmasq.sh` erzeugen aus den
-  eingecheckten `conf/*.conf`-Vorlagen (Platzhalter wie `__BIRD_ROUTER_ID__`,
-  `__DNSMASQ_SERVICE_IP__`) bei jedem Start neue `*.local.conf`-Dateien anhand der Werte aus
-  `general.local.conf` — die eingecheckten Vorlagen sind also keine fertigen Configs,
-  sondern Templates.
+- **Konfigurations-Templating:** `dnsmasq.sh` erzeugt aus der eingecheckten
+  `conf/dnsmasq.conf`-Vorlage (Platzhalter wie `__DNSMASQ_SERVICE_IP__`) bei jedem Start
+  eine `*.local.conf`-Datei anhand der Werte aus `general.local.conf`. Die
+  BIRD-/BIRD6-Konfiguration wird dagegen vom Ansible-Playbook
+  [ffc-mash](https://github.com/FreifunkChemnitz/ffc-mash) gerendert (Rolle
+  `ffc_vpn_gateway` → `/etc/bird/`), nicht mehr zur Laufzeit hier.
 
 ## Kopplung zwischen den Modulen
 
 Die Module sind nicht unabhängig, sondern bauen aufeinander auf:
 
-- `bird.sh`/`bird6.sh` iterieren über dieselbe `GRE_PEERS`-Liste wie `gre.sh`, um pro
-  GRE-Tunnel eine BGP-Session zum jeweiligen Nachbarserver zu konfigurieren.
+- Die Ansible-Rolle `ffc_vpn_gateway` leitet die BGP-Peers aus derselben Server-Menge
+  (Inventory-Gruppe `routers`) ab wie die GRE-Vollvermaschung, sodass pro GRE-Tunnel eine
+  BGP-Session zum jeweiligen Nachbarserver besteht. `bird.sh`/`bird6.sh` selbst richten nur
+  das Policy-Routing (Tabelle 100) ein.
 - `batman.sh` bindet die von `gre.sh` erzeugten Interfaces (`BATMAN_IFS`) sowie die von
   `fastd.sh` erzeugten Client-Tunnel in dieselbe batman-adv-Instanz (`bat0`) ein.
-- `radvd.sh` erfordert `USE_BIRD=1` und trägt seine Default-Route direkt in BIRD6 ein
-  (`bird6_add_route`).
-- `dnsmasq.sh` und die BGP-Konfiguration nutzen dieselben `SERVICE_ADDRESSES` (die
-  Dnsmasq-Gateway-Adresse wird zugleich als Route über BIRD announced).
+- `radvd.sh` erfordert `USE_BIRD=1`; die zugehörige IPv6-Default-Route in BIRD6 wird über
+  die Ansible-Rolle gesetzt (`ffc_vpn_gateway_bird_ipv6_uplink`).
 
 Das Zusammenspiel dieser Module ergibt das eigentliche Backbone-Netz — siehe
 [Backbone-Netzwerk](backbone-netzwerk.md) für die konzeptionelle Erklärung.

docs/backbone-netzwerk.md

@@ -136,32 +136,37 @@ Ausfallsicherheit über mehrere, unterschiedlich angebundene Server hinweg zu or
 Dafür betreibt jeder Server **BIRD** (IPv4) und **BIRD6** (IPv6) — je einen eigenen
 BGP-Router:
 
-- `lib/bird.sh`/`lib/bird6.sh` tragen für **jeden** GRE-Peer eine eigene interne
-  BGP-Session ein (`template bgp intern`), die genau über die Link-Local-Adressen des
-  jeweiligen GRE-Tunnels läuft. Damit hat jeder Server eine direkte BGP-Session zu jedem
-  anderen Server — eine [BGP-Vollvermaschung](#grundlagen-was-ist-eine-vollvermaschung)
-  passend zur GRE-Vollvermaschung.
+- Die BIRD-Konfiguration wird vom Ansible-Playbook
+  [ffc-mash](https://github.com/FreifunkChemnitz/ffc-mash) erzeugt (Rolle `ffc_vpn_gateway`
+  → `/etc/bird/`). Für **jeden** Server aus der Inventory-Gruppe `routers` wird eine eigene
+  interne BGP-Session eingetragen (`template bgp intern`), die genau über die
+  Link-Local-Adressen des jeweiligen GRE-Tunnels läuft. Damit hat jeder Server eine direkte
+  BGP-Session zu jedem anderen Server — eine
+  [BGP-Vollvermaschung](#grundlagen-was-ist-eine-vollvermaschung) passend zur
+  GRE-Vollvermaschung.
 - Jeder Server bekommt eine Router-ID/AS-Nummer, die aus seiner öffentlichen IP abgeleitet
   wird (`169.254.<3.Oktett>.<4.Oktett>` bzw. AS `<3.Oktett><4.Oktett>`) — ein einfaches,
   kollisionsfreies Schema ganz ohne zentrale IP-/AS-Vergabe.
 - Über BGP announcen die Server sich gegenseitig Routen: die eigene öffentliche IP
-  (`__WANIP__/32`), das Mesh-Netz (`10.149.0.0/20`), die konfigurierten Service-Adressen
-  sowie — nur auf Servern mit `USE_RADVD=1` — eine IPv6-Default-Route über den eigenen
-  Internet-Uplink (`radvd_add_route "::/0" "$WANGW6" "$WANIF"`).
+  (`<WANIP>/32`), das Mesh-Netz (`10.149.0.0/20`, Umland `10.149.16.0/20`), die
+  konfigurierten Service-Adressen sowie — auf IPv6-Uplink-Servern
+  (`ffc_vpn_gateway_bird_ipv6_uplink`) — eine IPv6-Default-Route über den eigenen
+  Internet-Uplink.
 - Damit ein Server für Mesh-Verkehr eine **eigene Routingtabelle** neben der normalen
-  Internet-Routingtabelle nutzt, richtet `bird_init`/`bird6_init` Policy-Routing ein
-  (`ip rule` für `10.149.0.0/16` bzw. `ip -6 rule` für `ffc2::/64`/`ffc3::/64`,
+  Internet-Routingtabelle nutzt, richtet `bird_init`/`bird6_init` (in `lib/`) Policy-Routing
+  ein (`ip rule` für `10.149.0.0/16` bzw. `ip -6 rule` für `ffc2::/64`/`ffc3::/64`,
   Ziel-Tabelle `100`) und BIRD selbst schreibt seine gelernten Routen in genau diese
   Tabelle (`kernel table 100`). So kann Mesh-Verkehr andere Pfade/Gateways nehmen als
   regulärer Internet-Verkehr des Servers.
-- **Ausnahme-/Regionalrouten:** `bird_init` rendert beim Setup aus
-  `conf/routes/_global.conf` und `conf/routes/<COUNTRY>.conf` die Datei
-  `conf/bird-routes.country.conf` (Platzhalter `NEXTHOP` → `$WANGW`), die per `include` in
-  `protocol static` einfließt — so lassen sich einzelne Zielnetze gezielt über das lokale
-  WAN-Gateway statt übers Mesh routen (z. B. Uni-Netze, Wikimedia, GitHub). Die Routen
-  werden im Repo gepflegt (`conf/routes/`); früher wurden sie alle 5 Minuten per `bird_cron`
-  von `api.chemnitz.freifunk.net` nachgeladen (Issue #7).
-- **NAT/Internet-Zugang:** `iptables -t nat -A POSTROUTING -o $WANIF -j MASQUERADE` sorgt
+- **Ausnahme-/Regionalrouten:** Die Ansible-Rolle rendert aus
+  `files/bird-routes/_global.conf` und `files/bird-routes/<CC>.conf` die Datei
+  `/etc/bird/bird-routes.country.conf` (Platzhalter `NEXTHOP` → lokales WAN-Gateway), die
+  per `include` in `protocol static` einfließt — so lassen sich einzelne Zielnetze gezielt
+  über das lokale WAN-Gateway statt übers Mesh routen (z. B. Uni-Netze, Wikimedia, GitHub).
+  Die Routen werden im ffc-mash-Playbook gepflegt; früher wurden sie alle 5 Minuten per
+  `bird_cron` von `api.chemnitz.freifunk.net` nachgeladen (Issue #7).
+- **NAT/Internet-Zugang:** `iptables -t nat -A POSTROUTING -o $WANIF -j MASQUERADE` (in
+  `lib/bird.sh`) sorgt
   dafür, dass Mesh-Clients über die öffentliche IP des jeweiligen Servers ins Internet
   können, wenn dieser Server als ihr Gateway gewählt wird.
 
@@ -174,8 +179,8 @@ BGP-Router:
    Backbone-Server hinweg, mit denen der Router nie direkt verbunden ist.
 3. Will der Router ins Internet, wählt er (bzw. das Mesh) einen Gateway-Server; dessen
    **BIRD/BIRD6**-Instanz hat über BGP von allen anderen Servern gelernt, welche Netze wie
-   erreichbar sind, trifft Routingentscheidungen (inkl. der statischen Ausnahmerouten aus
-   `conf/routes/`) und NATet den
+   erreichbar sind, trifft Routingentscheidungen (inkl. der statischen, per Ansible
+   gepflegten Ausnahmerouten) und NATet den
    Verkehr über die eigene öffentliche IP ins Internet.
 4. Für Verkehr zwischen zwei Mesh-Teilnehmern an unterschiedlichen Servern reicht bereits die
    batman-adv-Ebene ([Layer 2](#grundlagen-was-ist-ein-layer-2-netz)) — BGP wird hier nur zur Verteilung der Dienst-/Uplink-Routen