hetzner-k3s 0.5.0 → 0.5.4

data/lib/hetzner/infra/firewall.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hetzner
   class Firewall
     def initialize(hetzner_client:, cluster_name:)
@@ -5,38 +7,39 @@ module Hetzner
       @cluster_name = cluster_name
     end
 
-    def create(ha:, networks:)
-      @ha = ha
+    def create(high_availability:, networks:)
+      @high_availability = high_availability
       @networks = networks
       puts
 
-      if firewall = find_firewall
-        puts "Firewall already exists, skipping."
+      if (firewall = find_firewall)
+        puts 'Firewall already exists, skipping.'
         puts
-        return firewall["id"]
+        return firewall['id']
       end
 
-      puts "Creating firewall..."
+      puts 'Creating firewall...'
 
-      response = hetzner_client.post("/firewalls", create_firewall_config).body
-      puts "...firewall created."
+      response = hetzner_client.post('/firewalls', create_firewall_config).body
+      puts '...firewall created.'
       puts
 
-      JSON.parse(response)["firewall"]["id"]
+      JSON.parse(response)['firewall']['id']
     end
 
     def delete(servers)
-      if firewall = find_firewall
-        puts "Deleting firewall..."
+      if (firewall = find_firewall)
+        puts 'Deleting firewall...'
 
         servers.each do |server|
-          hetzner_client.post("/firewalls/#{firewall["id"]}/actions/remove_from_resources", remove_targets_config(server["id"]))
+          hetzner_client.post("/firewalls/#{firewall['id']}/actions/remove_from_resources",
+                              remove_targets_config(server['id']))
         end
 
-        hetzner_client.delete("/firewalls", firewall["id"])
-        puts "...firewall deleted."
+        hetzner_client.delete('/firewalls', firewall['id'])
+        puts '...firewall deleted.'
       else
-        puts "Firewall no longer exists, skipping."
+        puts 'Firewall no longer exists, skipping.'
       end
 
       puts
@@ -44,87 +47,86 @@ module Hetzner
 
     private
 
-      attr_reader :hetzner_client, :cluster_name, :firewall, :ha, :networks
-
-      def create_firewall_config
-        rules = [
-          {
-            "description": "Allow port 22 (SSH)",
-            "direction": "in",
-            "protocol": "tcp",
-            "port": "22",
-            "source_ips": networks,
-            "destination_ips": []
-          },
-          {
-            "description": "Allow ICMP (ping)",
-            "direction": "in",
-            "protocol": "icmp",
-            "port": nil,
-            "source_ips": [
-              "0.0.0.0/0",
-              "::/0"
-            ],
-            "destination_ips": []
-          },
-          {
-            "description": "Allow all TCP traffic between nodes on the private network",
-            "direction": "in",
-            "protocol": "tcp",
-            "port": "any",
-            "source_ips": [
-              "10.0.0.0/16"
-            ],
-            "destination_ips": []
-          },
-          {
-            "description": "Allow all UDP traffic between nodes on the private network",
-            "direction": "in",
-            "protocol": "udp",
-            "port": "any",
-            "source_ips": [
-              "10.0.0.0/16"
-            ],
-            "destination_ips": []
-          }
-        ]
-
-        unless ha
-          rules << {
-            "description": "Allow port 6443 (Kubernetes API server)",
-            "direction": "in",
-            "protocol": "tcp",
-            "port": "6443",
-            "source_ips": [
-              "0.0.0.0/0",
-              "::/0"
-            ],
-            "destination_ips": []
-          }
-        end
+    attr_reader :hetzner_client, :cluster_name, :firewall, :high_availability, :networks
 
+    def create_firewall_config
+      rules = [
         {
-          name: cluster_name,
-          rules: rules
-        }
-      end
-
-      def remove_targets_config(server_id)
+          description: 'Allow port 22 (SSH)',
+          direction: 'in',
+          protocol: 'tcp',
+          port: '22',
+          source_ips: networks,
+          destination_ips: []
+        },
+        {
+          description: 'Allow ICMP (ping)',
+          direction: 'in',
+          protocol: 'icmp',
+          port: nil,
+          source_ips: [
+            '0.0.0.0/0',
+            '::/0'
+          ],
+          destination_ips: []
+        },
+        {
+          description: 'Allow all TCP traffic between nodes on the private network',
+          direction: 'in',
+          protocol: 'tcp',
+          port: 'any',
+          source_ips: [
+            '10.0.0.0/16'
+          ],
+          destination_ips: []
+        },
         {
-          "remove_from": [
-            {
-              "server": {
-                "id": server_id
-              },
-              "type": "server"
-            }
-          ]
+          description: 'Allow all UDP traffic between nodes on the private network',
+          direction: 'in',
+          protocol: 'udp',
+          port: 'any',
+          source_ips: [
+            '10.0.0.0/16'
+          ],
+          destination_ips: []
+        }
+      ]
+
+      unless high_availability
+        rules << {
+          description: 'Allow port 6443 (Kubernetes API server)',
+          direction: 'in',
+          protocol: 'tcp',
+          port: '6443',
+          source_ips: [
+            '0.0.0.0/0',
+            '::/0'
+          ],
+          destination_ips: []
         }
       end
 
-      def find_firewall
-        hetzner_client.get("/firewalls")["firewalls"].detect{ |firewall| firewall["name"] == cluster_name }
-      end
+      {
+        name: cluster_name,
+        rules:
+      }
+    end
 
+    def remove_targets_config(server_id)
+      {
+        remove_from: [
+          {
+            server: {
+              id: server_id
+            },
+            type: 'server'
+          }
+        ]
+      }
+    end
+
+    def find_firewall
+      hetzner_client.get('/firewalls')['firewalls'].detect { |firewall| firewall['name'] == cluster_name }
+    end
   end
 end

data/lib/hetzner/infra/load_balancer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hetzner
   class LoadBalancer
     def initialize(hetzner_client:, cluster_name:)
@@ -11,31 +13,31 @@ module Hetzner
 
       puts
 
-      if load_balancer = find_load_balancer
-        puts "API load balancer already exists, skipping."
+      if (load_balancer = find_load_balancer)
+        puts 'API load balancer already exists, skipping.'
         puts
-        return load_balancer["id"]
+        return load_balancer['id']
       end
 
-      puts "Creating API load_balancer..."
+      puts 'Creating API load_balancer...'
 
-      response = hetzner_client.post("/load_balancers", create_load_balancer_config).body
-      puts "...API load balancer created."
+      response = hetzner_client.post('/load_balancers', create_load_balancer_config).body
+      puts '...API load balancer created.'
       puts
 
-      JSON.parse(response)["load_balancer"]["id"]
+      JSON.parse(response)['load_balancer']['id']
     end
 
-    def delete(ha:)
-      if load_balancer = find_load_balancer
-        puts "Deleting API load balancer..." unless ha
+    def delete(high_availability:)
+      if (load_balancer = find_load_balancer)
+        puts 'Deleting API load balancer...' unless high_availability
 
-        hetzner_client.post("/load_balancers/#{load_balancer["id"]}/actions/remove_target", remove_targets_config)
+        hetzner_client.post("/load_balancers/#{load_balancer['id']}/actions/remove_target", remove_targets_config)
 
-        hetzner_client.delete("/load_balancers", load_balancer["id"])
-        puts "...API load balancer deleted." unless ha
-      elsif ha
-        puts "API load balancer no longer exists, skipping."
+        hetzner_client.delete('/load_balancers', load_balancer['id'])
+        puts '...API load balancer deleted.' unless high_availability
+      elsif high_availability
+        puts 'API load balancer no longer exists, skipping.'
       end
 
       puts
@@ -43,54 +45,55 @@ module Hetzner
 
     private
 
-      attr_reader :hetzner_client, :cluster_name, :load_balancer, :location, :network_id
+    attr_reader :hetzner_client, :cluster_name, :load_balancer, :location, :network_id
 
-      def load_balancer_name
-        "#{cluster_name}-api"
-      end
+    def load_balancer_name
+      "#{cluster_name}-api"
+    end
 
-      def create_load_balancer_config
-        {
-          "algorithm": {
-            "type": "round_robin"
-          },
-          "load_balancer_type": "lb11",
-          "location": location,
-          "name": load_balancer_name,
-          "network": network_id,
-          "public_interface": true,
-          "services": [
-            {
-              "destination_port": 6443,
-              "listen_port": 6443,
-              "protocol": "tcp",
-              "proxyprotocol": false
-            }
-          ],
-          "targets": [
-            {
-              "label_selector": {
-                "selector": "cluster=#{cluster_name},role=master"
-              },
-              "type": "label_selector",
-              "use_private_ip": true
-            }
-          ]
-        }
-      end
+    def create_load_balancer_config
+      {
+        algorithm: {
+          type: 'round_robin'
+        },
+        load_balancer_type: 'lb11',
+        location:,
+        name: load_balancer_name,
+        network: network_id,
+        public_interface: true,
+        services: [
+          {
+            destination_port: 6443,
+            listen_port: 6443,
+            protocol: 'tcp',
+            proxyprotocol: false
+          }
+        ],
+        targets: [
+          {
+            label_selector: {
+              selector: "cluster=#{cluster_name},role=master"
+            },
+            type: 'label_selector',
+            use_private_ip: true
+          }
+        ]
+      }
+    end
 
-      def remove_targets_config
-        {
-          "label_selector": {
-            "selector": "cluster=#{cluster_name},role=master"
-          },
-          "type": "label_selector"
-        }
-      end
+    def remove_targets_config
+      {
+        label_selector: {
+          selector: "cluster=#{cluster_name},role=master"
+        },
+        type: 'label_selector'
+      }
+    end
 
-      def find_load_balancer
-        hetzner_client.get("/load_balancers")["load_balancers"].detect{ |load_balancer| load_balancer["name"] == load_balancer_name }
+    def find_load_balancer
+      hetzner_client.get('/load_balancers')['load_balancers'].detect do |load_balancer|
+        load_balancer['name'] == load_balancer_name
       end
-
+    end
   end
 end

data/lib/hetzner/infra/network.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hetzner
   class Network
     def initialize(hetzner_client:, cluster_name:)
@@ -9,29 +11,29 @@ module Hetzner
       @location = location
       puts
 
-      if network = find_network
-        puts "Private network already exists, skipping."
+      if (network = find_network)
+        puts 'Private network already exists, skipping.'
         puts
-        return network["id"]
+        return network['id']
       end
 
-      puts "Creating private network..."
+      puts 'Creating private network...'
 
-      response = hetzner_client.post("/networks", network_config).body
+      response = hetzner_client.post('/networks', network_config).body
 
-      puts "...private network created."
+      puts '...private network created.'
       puts
 
-      JSON.parse(response)["network"]["id"]
+      JSON.parse(response)['network']['id']
     end
 
     def delete
-      if network = find_network
-        puts "Deleting network..."
-        hetzner_client.delete("/networks", network["id"])
-        puts "...network deleted."
+      if (network = find_network)
+        puts 'Deleting network...'
+        hetzner_client.delete('/networks', network['id'])
+        puts '...network deleted.'
       else
-        puts "Network no longer exists, skipping."
+        puts 'Network no longer exists, skipping.'
       end
 
       puts
@@ -39,25 +41,24 @@ module Hetzner
 
     private
 
-      attr_reader :hetzner_client, :cluster_name, :location
-
-      def network_config
-        {
-          name: cluster_name,
-          ip_range: "10.0.0.0/16",
-          subnets: [
-            {
-              ip_range: "10.0.0.0/16",
-              network_zone: (location == "ash" ? "us-east" : "eu-central"),
-              type: "cloud"
-            }
-          ]
-        }
-      end
+    attr_reader :hetzner_client, :cluster_name, :location
 
-      def find_network
-        hetzner_client.get("/networks")["networks"].detect{ |network| network["name"] == cluster_name }
-      end
+    def network_config
+      {
+        name: cluster_name,
+        ip_range: '10.0.0.0/16',
+        subnets: [
+          {
+            ip_range: '10.0.0.0/16',
+            network_zone: (location == 'ash' ? 'us-east' : 'eu-central'),
+            type: 'cloud'
+          }
+        ]
+      }
+    end
 
+    def find_network
+      hetzner_client.get('/networks')['networks'].detect { |network| network['name'] == cluster_name }
+    end
   end
 end

data/lib/hetzner/infra/placement_group.rb

@@ -1,36 +1,39 @@
+# frozen_string_literal: true
+
 module Hetzner
   class PlacementGroup
-    def initialize(hetzner_client:, cluster_name:)
+    def initialize(hetzner_client:, cluster_name:, pool_name: nil)
       @hetzner_client = hetzner_client
       @cluster_name = cluster_name
+      @placement_group_name = pool_name ? "#{cluster_name}-#{pool_name}" : cluster_name
     end
 
     def create
       puts
 
       if (placement_group = find_placement_group)
-        puts "Placement group already exists, skipping."
+        puts "Placement group #{placement_group_name} already exists, skipping."
         puts
-        return placement_group["id"]
+        return placement_group['id']
       end
 
-      puts "Creating placement group..."
+      puts "Creating placement group #{placement_group_name}..."
 
-      response = hetzner_client.post("/placement_groups", placement_group_config).body
+      response = hetzner_client.post('/placement_groups', placement_group_config).body
 
-      puts "...placement group created."
+      puts "...placement group #{placement_group_name} created."
       puts
 
-      JSON.parse(response)["placement_group"]["id"]
+      JSON.parse(response)['placement_group']['id']
     end
 
     def delete
       if (placement_group = find_placement_group)
-        puts "Deleting placement group..."
-        hetzner_client.delete("/placement_groups", placement_group["id"])
-        puts "...placement group deleted."
+        puts "Deleting placement group #{placement_group_name}..."
+        hetzner_client.delete('/placement_groups', placement_group['id'])
+        puts "...placement group #{placement_group_name} deleted."
       else
-        puts "Placement group no longer exists, skipping."
+        puts "Placement group #{placement_group_name} no longer exists, skipping."
       end
 
       puts
@@ -38,18 +41,19 @@ module Hetzner
 
     private
 
-      attr_reader :hetzner_client, :cluster_name
+    attr_reader :hetzner_client, :cluster_name, :placement_group_name
 
-      def placement_group_config
-        {
-          name: cluster_name,
-          type: "spread"
-        }
-      end
+    def placement_group_config
+      {
+        name: placement_group_name,
+        type: 'spread'
+      }
+    end
 
-      def find_placement_group
-        hetzner_client.get("/placement_groups")["placement_groups"].detect{ |placement_group| placement_group["name"] == cluster_name }
+    def find_placement_group
+      hetzner_client.get('/placement_groups')['placement_groups'].detect do |placement_group|
+        placement_group['name'] == placement_group_name
       end
-
+    end
   end
 end

data/lib/hetzner/infra/server.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hetzner
   class Server
     def initialize(hetzner_client:, cluster_name:)
@@ -12,7 +14,7 @@ module Hetzner
 
       server_name = "#{cluster_name}-#{instance_type}-#{instance_id}"
 
-      if server = find_server(server_name)
+      if (server = find_server(server_name))
         puts "Server #{server_name} already exists, skipping."
         puts
         return server
@@ -22,8 +24,8 @@ module Hetzner
 
       server_config = {
         name: server_name,
-        location: location,
-        image: image,
+        location:,
+        image:,
         firewalls: [
           { firewall: firewall_id }
         ],
@@ -34,18 +36,18 @@ module Hetzner
         ssh_keys: [
           ssh_key_id
         ],
-        user_data: user_data,
+        user_data:,
         labels: {
           cluster: cluster_name,
-          role: (server_name =~ /master/ ? "master" : "worker")
+          role: (server_name =~ /master/ ? 'master' : 'worker')
         },
         placement_group: placement_group_id
       }
 
-      response = hetzner_client.post("/servers", server_config)
+      response = hetzner_client.post('/servers', server_config)
       response_body = response.body
 
-      server = JSON.parse(response_body)["server"]
+      server = JSON.parse(response_body)['server']
 
       unless server
         puts "Error creating server #{server_name}. Response details below:"
@@ -61,9 +63,9 @@ module Hetzner
     end
 
     def delete(server_name:)
-      if server = find_server(server_name)
+      if (server = find_server(server_name))
         puts "Deleting server #{server_name}..."
-        hetzner_client.delete "/servers", server["id"]
+        hetzner_client.delete '/servers', server['id']
         puts "...server #{server_name} deleted."
       else
         puts "Server #{server_name} no longer exists, skipping."
@@ -72,31 +74,30 @@ module Hetzner
 
     private
 
-      attr_reader :hetzner_client, :cluster_name, :additional_packages
-
-      def find_server(server_name)
-        hetzner_client.get("/servers?sort=created:desc")["servers"].detect{ |network| network["name"] == server_name }
-      end
+    attr_reader :hetzner_client, :cluster_name, :additional_packages
 
-      def user_data
-        packages = ["fail2ban"]
-        packages += additional_packages if additional_packages
-        packages = "'" + packages.join("', '") + "'"
-
-        <<~EOS
-          #cloud-config
-          packages: [#{packages}]
-          runcmd:
-            - sed -i 's/[#]*PermitRootLogin yes/PermitRootLogin prohibit-password/g' /etc/ssh/sshd_config
-            - sed -i 's/[#]*PasswordAuthentication yes/PasswordAuthentication no/g' /etc/ssh/sshd_config
-            - systemctl restart sshd
-            - systemctl stop systemd-resolved
-            - systemctl disable systemd-resolved
-            - rm /etc/resolv.conf
-            - echo "nameserver 1.1.1.1" > /etc/resolv.conf
-            - echo "nameserver 1.0.0.1" >> /etc/resolv.conf
-        EOS
-      end
+    def find_server(server_name)
+      hetzner_client.get('/servers?sort=created:desc')['servers'].detect { |network| network['name'] == server_name }
+    end
 
+    def user_data
+      packages = ['fail2ban', 'wireguard']
+      packages += additional_packages if additional_packages
+      packages = "'#{packages.join("', '")}'"
+
+      <<~YAML
+        #cloud-config
+        packages: [#{packages}]
+        runcmd:
+          - sed -i 's/[#]*PermitRootLogin yes/PermitRootLogin prohibit-password/g' /etc/ssh/sshd_config
+          - sed -i 's/[#]*PasswordAuthentication yes/PasswordAuthentication no/g' /etc/ssh/sshd_config
+          - systemctl restart sshd
+          - systemctl stop systemd-resolved
+          - systemctl disable systemd-resolved
+          - rm /etc/resolv.conf
+          - echo "nameserver 1.1.1.1" > /etc/resolv.conf
+          - echo "nameserver 1.0.0.1" >> /etc/resolv.conf
+      YAML
+    end
   end
 end