cookbooks/networking/recipes/default.rb

   1 #
   2 # Cookbook:: networking
   3 # Recipe:: default
   4 #
   5 # Copyright:: 2010, OpenStreetMap Foundation.
   6 # Copyright:: 2009, Opscode, Inc.
   7 #
   8 # Licensed under the Apache License, Version 2.0 (the "License");
   9 # you may not use this file except in compliance with the License.
  10 # You may obtain a copy of the License at
  11 #
  12 #     https://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing, software
  15 # distributed under the License is distributed on an "AS IS" BASIS,
  16 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 # See the License for the specific language governing permissions and
  18 # limitations under the License.
  19 #
  20 # = Requires
  21 # * node[:networking][:nameservers]
  22
  23 require "ipaddr"
  24 require "yaml"
  25
  26 include_recipe "ruby"
  27
  28 keys = data_bag_item("networking", "keys")
  29
  30 file "/etc/netplan/00-installer-config.yaml" do
  31   action :delete
  32 end
  33
  34 file "/etc/netplan/01-netcfg.yaml" do
  35   action :delete
  36 end
  37
  38 file "/etc/netplan/50-cloud-init.yaml" do
  39   action :delete
  40 end
  41
  42 file "/etc/netplan/99-chef.yaml" do
  43   action :delete
  44 end
  45
  46 package "ifupdown" do
  47   action :purge
  48 end
  49
  50 package "netplan.io" do
  51   action :purge
  52 end
  53
  54 package "cloud-init" do
  55   action :purge
  56 end
  57
  58 interfaces = node[:networking][:interfaces].collect do |name, interface|
  59   [interface[:interface], name]
  60 end.to_h
  61
  62 node[:networking][:interfaces].each do |name, interface|
  63   if interface[:interface] =~ /^(.*)\.(\d+)$/
  64     vlan_interface = Regexp.last_match(1)
  65     vlan_id = Regexp.last_match(2)
  66
  67     parent = interfaces[vlan_interface] || "vlans_#{vlan_interface}"
  68
  69     node.default_unless[:networking][:interfaces][parent][:interface] = vlan_interface
  70     node.default_unless[:networking][:interfaces][parent][:vlans] = []
  71
  72     node.default[:networking][:interfaces][parent][:vlans] << vlan_id
  73   end
  74
  75   next unless interface[:role] && (role = node[:networking][:roles][interface[:role]])
  76
  77   if interface[:inet] && role[:inet]
  78     node.default_unless[:networking][:interfaces][name][:inet][:prefix] = role[:inet][:prefix]
  79     node.default_unless[:networking][:interfaces][name][:inet][:gateway] = role[:inet][:gateway]
  80     node.default_unless[:networking][:interfaces][name][:inet][:routes] = role[:inet][:routes]
  81   end
  82
  83   if interface[:inet6] && role[:inet6]
  84     node.default_unless[:networking][:interfaces][name][:inet6][:prefix] = role[:inet6][:prefix]
  85     node.default_unless[:networking][:interfaces][name][:inet6][:gateway] = role[:inet6][:gateway]
  86     node.default_unless[:networking][:interfaces][name][:inet6][:routes] = role[:inet6][:routes]
  87   end
  88
  89   node.default_unless[:networking][:interfaces][name][:metric] = role[:metric]
  90   node.default_unless[:networking][:interfaces][name][:zone] = role[:zone]
  91 end
  92
  93 node[:networking][:interfaces].each do |_, interface|
  94   if interface[:interface] =~ /^.*\.(\d+)$/
  95     template "/etc/systemd/network/10-#{interface[:interface]}.netdev" do
  96       source "vlan.netdev.erb"
  97       owner "root"
  98       group "root"
  99       mode "644"
 100       variables :interface => interface, :vlan => Regexp.last_match(1)
 101       notifies :run, "notify_group[networkctl-reload]"
 102     end
 103   elsif interface[:interface] =~ /^bond\d+$/
 104     template "/etc/systemd/network/10-#{interface[:interface]}.netdev" do
 105       source "bond.netdev.erb"
 106       owner "root"
 107       group "root"
 108       mode "644"
 109       variables :interface => interface
 110       notifies :run, "notify_group[networkctl-reload]"
 111     end
 112
 113     interface[:bond][:slaves].each do |slave|
 114       template "/etc/systemd/network/10-#{slave}.network" do
 115         source "slave.network.erb"
 116         owner "root"
 117         group "root"
 118         mode "644"
 119         variables :master => interface, :slave => slave
 120         notifies :run, "notify_group[networkctl-reload]"
 121       end
 122     end
 123   end
 124
 125   template "/etc/systemd/network/10-#{interface[:interface]}.network" do
 126     source "network.erb"
 127     owner "root"
 128     group "root"
 129     mode "644"
 130     variables :interface => interface
 131     notifies :run, "notify_group[networkctl-reload]"
 132   end
 133 end
 134
 135 package "systemd-resolved" do
 136   action :install
 137   only_if { platform?("ubuntu") && node[:lsb][:release].to_f > 22.04 || platform?("debian") && node[:lsb][:release].to_f > 11.0 }
 138 end
 139
 140 service "systemd-networkd" do
 141   action [:enable, :start]
 142 end
 143
 144 if node[:networking][:wireguard][:enabled]
 145   wireguard_id = persistent_token("networking", "wireguard")
 146
 147   node.default[:networking][:wireguard][:address] = "fd43:e709:ea6d:1:#{wireguard_id[0, 4]}:#{wireguard_id[4, 4]}:#{wireguard_id[8, 4]}:#{wireguard_id[12, 4]}"
 148
 149   package "wireguard-tools" do
 150     compile_time true
 151     options "--no-install-recommends"
 152   end
 153
 154   directory "/var/lib/systemd/wireguard" do
 155     owner "root"
 156     group "systemd-network"
 157     mode "750"
 158     compile_time true
 159   end
 160
 161   file "/var/lib/systemd/wireguard/private.key" do
 162     action :create_if_missing
 163     owner "root"
 164     group "systemd-network"
 165     mode "640"
 166     content %x(wg genkey)
 167     compile_time true
 168   end
 169
 170   node.default[:networking][:wireguard][:public_key] = %x(wg pubkey < /var/lib/systemd/wireguard/private.key).chomp
 171
 172   file "/var/lib/systemd/wireguard/preshared.key" do
 173     action :create_if_missing
 174     owner "root"
 175     group "systemd-network"
 176     mode "640"
 177     content keys["wireguard"]
 178   end
 179
 180   if node[:roles].include?("gateway")
 181     search(:node, "roles:gateway") do |gateway|
 182       next if gateway.name == node.name
 183       next unless gateway[:networking][:wireguard] && gateway[:networking][:wireguard][:enabled]
 184
 185       allowed_ips = gateway.ipaddresses(:role => :internal).map(&:subnet)
 186
 187       node.default[:networking][:wireguard][:peers] << {
 188         :public_key => gateway[:networking][:wireguard][:public_key],
 189         :allowed_ips => allowed_ips,
 190         :endpoint => "#{gateway.name}:51820"
 191       }
 192     end
 193
 194     search(:node, "roles:prometheus") do |server|
 195       allowed_ips = server.ipaddresses(:role => :internal).map(&:subnet)
 196
 197       if server[:networking][:private_address]
 198         allowed_ips << "#{server[:networking][:private_address]}/32"
 199       end
 200
 201       node.default[:networking][:wireguard][:peers] << {
 202         :public_key => server[:networking][:wireguard][:public_key],
 203         :allowed_ips => allowed_ips,
 204         :endpoint => "#{server.name}:51820"
 205       }
 206     end
 207
 208     node.default[:networking][:wireguard][:peers] << {
 209       :public_key => "7Oj9ufNlgidyH/xDc+aHQKMjJPqTmD/ab13agMh6AxA=",
 210       :allowed_ips => "10.0.16.1/32",
 211       :endpoint => "gate.compton.nu:51820"
 212     }
 213
 214     # Grant home
 215     node.default[:networking][:wireguard][:peers] << {
 216       :public_key => "RofATnvlWxP3mt87+QKRXFE5MVxtoCcTsJ+yftZYEE4=",
 217       :allowed_ips => "10.89.122.1/32",
 218       :endpoint => "gate.firefishy.com:51820"
 219     }
 220
 221     # Grant roaming
 222     node.default[:networking][:wireguard][:peers] << {
 223       :public_key => "YbUkREE9TAmomqgL/4Fh2e5u2Hh7drN/2o5qg3ndRxg=",
 224       :allowed_ips => "10.89.123.1/32",
 225       :endpoint => "roaming.firefishy.com:51820"
 226     }
 227   elsif node[:roles].include?("shenron")
 228     search(:node, "roles:gateway") do |gateway|
 229       allowed_ips = gateway.ipaddresses(:role => :internal).map(&:subnet)
 230
 231       node.default[:networking][:wireguard][:peers] << {
 232         :public_key => gateway[:networking][:wireguard][:public_key],
 233         :allowed_ips => allowed_ips,
 234         :endpoint => "#{gateway.name}:51820"
 235       }
 236     end
 237   end
 238
 239   file "/etc/systemd/network/wireguard.netdev" do
 240     action :delete
 241   end
 242
 243   template "/etc/systemd/network/10-wg0.netdev" do
 244     source "wireguard.netdev.erb"
 245     owner "root"
 246     group "systemd-network"
 247     mode "640"
 248     notifies :run, "execute[networkctl-delete-wg0]"
 249     notifies :run, "notify_group[networkctl-reload]"
 250   end
 251
 252   file "/etc/systemd/network/wireguard.network" do
 253     action :delete
 254   end
 255
 256   template "/etc/systemd/network/10-wg0.network" do
 257     source "wireguard.network.erb"
 258     owner "root"
 259     group "root"
 260     mode "644"
 261     notifies :run, "execute[networkctl-reload]"
 262   end
 263
 264   execute "networkctl-delete-wg0" do
 265     action :nothing
 266     command "networkctl delete wg0"
 267     only_if { ::File.exist?("/sys/class/net/wg0") }
 268   end
 269 end
 270
 271 # Setup dokken network in systemd-networkd to avoid systemd-networkd-wait-online delay
 272 template "/etc/systemd/network/dokken.network" do
 273   source "dokken.network.erb"
 274   owner "root"
 275   group "root"
 276   mode "644"
 277   notifies :run, "execute[networkctl-reload]", :immediately
 278   only_if { kitchen? }
 279 end
 280
 281 notify_group "networkctl-reload"
 282
 283 execute "networkctl-reload" do
 284   action :nothing
 285   command "networkctl reload"
 286   subscribes :run, "notify_group[networkctl-reload]"
 287 end
 288
 289 ohai "reload-hostname" do
 290   action :nothing
 291   plugin "hostname"
 292 end
 293
 294 execute "hostnamectl-set-hostname" do
 295   command "hostnamectl set-hostname #{node[:networking][:hostname]}"
 296   notifies :reload, "ohai[reload-hostname]"
 297   not_if { kitchen? || node[:hostnamectl][:static_hostname] == node[:networking][:hostname] }
 298 end
 299
 300 template "/etc/hosts" do
 301   source "hosts.erb"
 302   owner "root"
 303   group "root"
 304   mode "644"
 305   not_if { kitchen? }
 306 end
 307
 308 service "systemd-resolved" do
 309   action [:enable, :start]
 310 end
 311
 312 directory "/etc/systemd/resolved.conf.d" do
 313   owner "root"
 314   group "root"
 315   mode "755"
 316 end
 317
 318 template "/etc/systemd/resolved.conf.d/99-chef.conf" do
 319   source "resolved.conf.erb"
 320   owner "root"
 321   group "root"
 322   mode "644"
 323   notifies :restart, "service[systemd-resolved]", :immediately
 324 end
 325
 326 if node[:filesystem][:by_mountpoint][:"/etc/resolv.conf"]
 327   execute "umount-resolve-conf" do
 328     command "umount -c /etc/resolv.conf"
 329   end
 330 end
 331
 332 link "/etc/resolv.conf" do
 333   to "../run/systemd/resolve/stub-resolv.conf"
 334 end
 335
 336 gem_package "dbus-systemd" do
 337   gem_binary node[:ruby][:gem]
 338 end
 339
 340 prometheus_exporter "resolved" do
 341   port 10028
 342   user "systemd-resolve"
 343   restrict_address_families "AF_UNIX"
 344 end
 345
 346 hosts = { :inet => [], :inet6 => [] }
 347
 348 search(:node, "networking:interfaces").collect do |n|
 349   next if n[:fqdn] == node[:fqdn]
 350
 351   n.interfaces.each do |interface|
 352     next unless interface[:role] == "external"
 353
 354     hosts[:inet] << interface[:inet][:address] if interface[:inet]
 355     hosts[:inet6] << interface[:inet6][:address] if interface[:inet6]
 356   end
 357 end
 358
 359 package "nftables"
 360
 361 interfaces = []
 362
 363 node.interfaces(:role => :external).each do |interface|
 364   interfaces << interface[:interface]
 365 end
 366
 367 template "/etc/nftables.conf" do
 368   source "nftables.conf.erb"
 369   owner "root"
 370   group "root"
 371   mode "755"
 372   variables :interfaces => interfaces, :hosts => hosts
 373   notifies :reload, "service[nftables]"
 374 end
 375
 376 directory "/var/lib/nftables" do
 377   owner "root"
 378   group "root"
 379   mode "755"
 380 end
 381
 382 template "/usr/local/bin/nftables" do
 383   source "nftables.erb"
 384   owner "root"
 385   group "root"
 386   mode "755"
 387 end
 388
 389 systemd_service "nftables-stop" do
 390   action :delete
 391   service "nftables"
 392   dropin "stop"
 393 end
 394
 395 systemd_service "nftables-chef" do
 396   service "nftables"
 397   dropin "chef"
 398   exec_start "/usr/local/bin/nftables start"
 399   exec_reload "/usr/local/bin/nftables reload"
 400   exec_stop "/usr/local/bin/nftables stop"
 401 end
 402
 403 if node[:networking][:firewall][:enabled]
 404   service "nftables" do
 405     action [:enable, :start]
 406   end
 407 else
 408   service "nftables" do
 409     action [:disable, :stop]
 410   end
 411 end
 412
 413 if node[:networking][:wireguard][:enabled]
 414   firewall_rule "accept-wireguard" do
 415     action :accept
 416     context :incoming
 417     protocol :udp
 418     source :osm unless node[:roles].include?("gateway")
 419     dest_ports "51820"
 420     source_ports "51820"
 421   end
 422 end
 423
 424 firewall_rule "accept-http-osm" do
 425   action :accept
 426   context :incoming
 427   protocol :tcp
 428   source :osm
 429   dest_ports %w[http https]
 430 end
 431
 432 firewall_rule "accept-http" do
 433   action :accept
 434   context :incoming
 435   protocol :tcp
 436   dest_ports %w[http https]
 437   rate_limit node[:networking][:firewall][:http_rate_limit]
 438   connection_limit node[:networking][:firewall][:http_connection_limit]
 439 end