knife-ionoscloud 5.1.2 → 6.0.0.alpha.1

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_target_remove.rb

@@ -0,0 +1,105 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerRuleTargetRemove < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer rule target remove (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      option :network_loadbalancer_id,
+              short: '-L NETWORK_LOADBALANCER_ID',
+              long: '--network-loadbalancer NETWORK_LOADBALANCER_ID',
+              description: 'ID of the Network Loadbalancer'
+
+      option :forwarding_rule_id,
+              short: '-R FORWARDING_RULE_ID',
+              long: '--forwarding-rule FORWARDING_RULE_ID',
+              description: 'ID of the Network Loadbalancer Forwarding Rule'
+
+      option :ip,
+              short: '-i IP',
+              long: '--ip IP',
+              description: 'IP of a balanced target VM'
+
+      option :port,
+              short: '-p PORT',
+              long: '--port PORT',
+              description: 'Port of the balanced target service. (range: 1 to 65535)'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Adds a target to a Network Load Balancer Forwarding Rule under a data center.'
+        @required_options = [
+          :datacenter_id, :network_loadbalancer_id, :forwarding_rule_id, :ip, :port, :ionoscloud_username, :ionoscloud_password,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        network_loadbalancers_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+
+
+        network_load_balancer_rule = network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_find_by_forwarding_rule_id(
+          config[:datacenter_id], config[:network_loadbalancer_id], config[:forwarding_rule_id],
+        )
+
+        initial_length = network_load_balancer_rule.properties.targets.length
+
+        network_load_balancer_rule.properties.targets = network_load_balancer_rule.properties.targets.reject do
+          |target|
+          target.ip == config[:ip] && target.port == Integer(config[:port])
+        end
+
+        if initial_length > network_load_balancer_rule.properties.targets.length
+          _, _, headers  = network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_patch_with_http_info(
+            config[:datacenter_id],
+            config[:network_loadbalancer_id],
+            config[:forwarding_rule_id],
+            Ionoscloud::NetworkLoadBalancerForwardingRuleProperties.new({
+              targets: network_load_balancer_rule.properties.targets,
+            }),
+          )
+
+          print "#{ui.color('Removing the target from the Network Loadbalancer Forwarding Rule...', :magenta)}"
+          dot = ui.color('.', :magenta)
+          api_client.wait_for { print dot; is_done? get_request_id headers }
+        end
+
+        network_load_balancer_rule = network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_find_by_forwarding_rule_id(
+          config[:datacenter_id], config[:network_loadbalancer_id], config[:forwarding_rule_id], depth: 2,
+        )
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{network_load_balancer_rule.id}"
+        puts "#{ui.color('Name', :cyan)}: #{network_load_balancer_rule.properties.name}"
+        puts "#{ui.color('Algorithm', :cyan)}: #{network_load_balancer_rule.properties.algorithm}"
+        puts "#{ui.color('Protocol', :cyan)}: #{network_load_balancer_rule.properties.protocol}"
+        puts "#{ui.color('Listener IP', :cyan)}: #{network_load_balancer_rule.properties.listener_ip}"
+        puts "#{ui.color('Listener Port', :cyan)}: #{network_load_balancer_rule.properties.listener_port}"
+        puts "#{ui.color('Health Check', :cyan)}: #{network_load_balancer_rule.properties.health_check}"
+        puts "#{ui.color('Targets', :cyan)}: #{network_load_balancer_rule.properties.targets.map do |target|
+          {
+            ip: target.ip,
+            port: target.port,
+            weight: target.weight,
+            check: target.health_check.check,
+            check_interval: target.health_check.check_interval,
+            maintenance: target.health_check.maintenance,
+          }
+        end}"
+        puts 'done'
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_nic_create.rb

@@ -28,7 +28,10 @@ class Chef
               description: 'IPs assigned to the NIC'
 
       option :dhcp,
-              long: '--dhcp DHCP',
+              short: '-d',
+              long: '--dhcp',
+              boolean: true | false,
+              default: true,
               description: 'Set to false if you wish to disable DHCP'
 
       option :lan,
@@ -36,9 +39,12 @@ class Chef
               long: '--lan ID',
               description: 'The LAN ID the NIC will reside on; if the LAN ID does not exist it will be created'
 
-      option :nat,
-              long: '--nat NAT',
-              description: 'Set to enable NAT on the NIC'
+      option :firewall_type,
+              short: '-t FIREWALL_TYPE',
+              long: '--firewall-type FIREWALL_TYPE',
+              description: 'The type of firewall rules that will be allowed on the NIC. If it is not specified it will take the '\
+              'default value INGRESS',
+              default: 'INGRESS'
 
       attr_reader :description, :required_options
 
@@ -52,37 +58,50 @@ class Chef
 
       def run
         $stdout.sync = true
-        handle_extra_config
         validate_required_params(@required_options, config)
 
         print "#{ui.color('Creating nic...', :magenta)}"
 
-        config[:ips] = config[:ips].split(',') if config[:ips] && config[:ips].instance_of?(String)
+        if config[:ips]
+          config[:ips] = config[:ips].split(',')
+        end
 
-        nic_api = Ionoscloud::NicApi.new(api_client)
+        nic_properties = {
+          name: config[:name],
+          ips: config[:ips],
+          dhcp: config[:dhcp],
+          lan: config[:lan],
+          firewall_type: config[:firewall_type]
+        }.compact
+
+        nic_api = Ionoscloud::NetworkInterfacesApi.new(api_client)
 
         nic, _, headers = nic_api.datacenters_servers_nics_post_with_http_info(
           config[:datacenter_id],
           config[:server_id],
-          Ionoscloud::Nic.new(
-            properties: Ionoscloud::NicProperties.new(
-              name: config[:name],
-              ips: config[:ips],
-              dhcp: (config.key?(:dhcp) ? config[:dhcp].to_s.downcase == 'true' : nil),
-              lan: config[:lan],
-              nat: (config.key?(:nat) ? config[:nat].to_s.downcase == 'true' : nil),
-            ),
-          ),
+          Ionoscloud::Nic.new(properties: Ionoscloud::NicProperties.new(**nic_properties)),
         )
 
         dot = ui.color('.', :magenta)
         api_client.wait_for { print dot; is_done? get_request_id headers }
 
-        print_nic(nic_api.datacenters_servers_nics_find_by_id(
-                    config[:datacenter_id],
+        nic = nic_api.datacenters_servers_nics_find_by_id(
+          config[:datacenter_id],
           config[:server_id],
           nic.id,
-        ))
+        )
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{nic.id}"
+        puts "#{ui.color('Name', :cyan)}: #{nic.properties.name}"
+        puts "#{ui.color('IPs', :cyan)}: #{nic.properties.ips.to_s}"
+        puts "#{ui.color('DHCP', :cyan)}: #{nic.properties.dhcp}"
+        puts "#{ui.color('LAN', :cyan)}: #{nic.properties.lan}"
+        puts "#{ui.color('Firewall Type', :cyan)}: #{nic.properties.firewall_type}"
+        puts "#{ui.color('Device Number', :cyan)}: #{nic.properties.device_number}"
+        puts "#{ui.color('PCI Slot', :cyan)}: #{nic.properties.pci_slot}"
+
+        puts 'done'
       end
     end
   end

data/lib/chef/knife/ionoscloud_nic_delete.rb

@@ -15,7 +15,7 @@ class Chef
       option :server_id,
               short: '-S SERVER_ID',
               long: '--server-id SERVER_ID',
-              description: 'The ID of the server to which the NIC is assigned'
+              description: 'The ID of the server assigned the NIC'
 
       attr_reader :description, :required_options
 
@@ -28,10 +28,9 @@ class Chef
 
       def run
         $stdout.sync = true
-        handle_extra_config
         validate_required_params(@required_options, config)
 
-        nic_api = Ionoscloud::NicApi.new(api_client)
+        nic_api = Ionoscloud::NetworkInterfacesApi.new(api_client)
         @name_args.each do |nic_id|
           begin
             nic = nic_api.datacenters_servers_nics_find_by_id(config[:datacenter_id], config[:server_id], nic_id)
@@ -40,8 +39,15 @@ class Chef
             ui.error("Nic ID #{nic_id} not found. Skipping.")
             next
           end
-          print_nic(nic)
-          puts "\n"
+
+          msg_pair('ID', nic.id)
+          msg_pair('Name', nic.properties.name)
+          msg_pair('IPs', nic.properties.ips)
+          msg_pair('DHCP', nic.properties.dhcp)
+          msg_pair('LAN', nic.properties.lan)
+          msg_pair('Firewall Type', nic.properties.firewall_type)
+          msg_pair('Device Number', nic.properties.device_number)
+          msg_pair('PCI Slot', nic.properties.pci_slot)
 
           begin
             confirm('Do you really want to delete this Nic')

data/lib/chef/knife/ionoscloud_nic_list.rb

@@ -28,7 +28,6 @@ class Chef
 
       def run
         $stdout.sync = true
-        handle_extra_config
         validate_required_params(@required_options, config)
 
         nic_list = [
@@ -36,22 +35,26 @@ class Chef
           ui.color('Name', :bold),
           ui.color('IPs', :bold),
           ui.color('DHCP', :bold),
-          ui.color('NAT', :bold),
-          ui.color('LAN', :bold)
+          ui.color('LAN', :bold),
+          ui.color('Firewall Type', :bold),
+          ui.color('Device Number', :bold),
+          ui.color('PCI Slot', :bold),
         ]
 
-        nic_api = Ionoscloud::NicApi.new(api_client)
+        nic_api = Ionoscloud::NetworkInterfacesApi.new(api_client)
 
         nic_api.datacenters_servers_nics_get(config[:datacenter_id], config[:server_id], { depth: 1 }).items.each do |nic|
           nic_list << nic.id
           nic_list << nic.properties.name
           nic_list << nic.properties.ips.to_s
           nic_list << nic.properties.dhcp.to_s
-          nic_list << nic.properties.nat.to_s
           nic_list << nic.properties.lan.to_s
+          nic_list << nic.properties.firewall_type.to_s
+          nic_list << nic.properties.device_number.to_s
+          nic_list << nic.properties.pci_slot.to_s
         end
 
-        puts ui.list(nic_list, :uneven_columns_across, 6)
+        puts ui.list(nic_list, :uneven_columns_across, 8)
       end
     end
   end

data/lib/chef/knife/ionoscloud_node_delete.rb

@@ -29,7 +29,6 @@ class Chef
 
       def run
         $stdout.sync = true
-        handle_extra_config
         validate_required_params(@required_options, config)
 
         kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
@@ -42,7 +41,12 @@ class Chef
             ui.error("K8s Node ID #{node_id} not found. Skipping.")
             next
           end
-          print_k8s_node(node)
+
+          msg_pair('ID', node.id)
+          msg_pair('Name', node.properties.name)
+          msg_pair('Public IP', node.properties.public_ip)
+          msg_pair('K8s Version', node.properties.k8s_version)
+          msg_pair('State', node.metadata.state)
 
           puts "\n"
 

data/lib/chef/knife/ionoscloud_node_list.rb

@@ -12,7 +12,6 @@ class Chef
               long: '--cluster-id CLUSTER_ID',
               description: 'The ID of the K8s Cluster'
 
-
       option :nodepool_id,
               short: '-P NODEPOOL_ID',
               long: '--nodepool-id NODEPOOL_ID',
@@ -29,7 +28,6 @@ class Chef
 
       def run
         $stdout.sync = true
-        handle_extra_config
         validate_required_params(@required_options, config)
 
         node_list = [

data/lib/chef/knife/ionoscloud_node_replace.rb

@@ -33,7 +33,6 @@ class Chef
 
       def run
         $stdout.sync = true
-        handle_extra_config
         validate_required_params(@required_options, config)
 
         kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)

data/lib/chef/knife/ionoscloud_nodepool_create.rb

@@ -22,12 +22,13 @@ class Chef
               long: '--name NAME',
               description: 'Name of the Kubernetes node pool'
 
-      option :k8s_version,
+      option :version,
               short: '-v VERSION',
               long: '--version VERSION',
-              description: 'The version for the Kubernetes Nodepool.'
+              description: 'The version for the Kubernetes cluster.'
 
       option :maintenance_day,
+              short: '-d MAINTENANCE_DAY',
               long: '--maintenance-day MAINTENANCE_DAY',
               description: 'Day Of the week when to perform the maintenance.'
 
@@ -90,14 +91,6 @@ class Chef
               'must contain one extra IP than maximum number of nodes could be. (nodeCount+1 if fixed '\
               'node amount or maxNodeCount+1 if auto scaling is used) The extra provided IP Will be used during rebuilding of nodes.'
 
-      option :labels,
-              long: '--labels LABEL [LABEL]',
-              description: 'map of labels attached to node pool'
-
-      option :annotations,
-              long: '--annotations ANNOTATION [ANNOTATION]',
-              description: 'map of annotations attached to node pool'
-
       attr_reader :description, :required_options
 
       def initialize(args = [])
@@ -107,28 +100,24 @@ class Chef
         "The Kubernetes cluster must be in state \"ACTIVE\" before creating a node pool.\n\n"\
         "The worker nodes within the node pools will be deployed into an existing data centers."
         @required_options = [
-          :datacenter_id, :cluster_id, :name, :k8s_version, :node_count, :cpu_family, :cores, :ram,
+          :datacenter_id, :cluster_id, :name, :version, :node_count, :cpu_family, :cores, :ram,
           :availability_zone, :storage_type, :storage_size, :ionoscloud_username, :ionoscloud_password,
         ]
       end
 
       def run
         $stdout.sync = true
-        handle_extra_config
         validate_required_params(@required_options, config)
 
         print "#{ui.color('Creating K8s Nodepool...', :magenta)}"
 
         kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
 
-        config[:public_ips] = config[:public_ips].split(',') if config[:public_ips] && config[:public_ips].instance_of?(String)
-        config[:lans] = config[:lans].split(',') if config[:lans] && config[:lans].instance_of?(String)
-        config[:labels] = JSON[config[:labels]] if config[:labels] && config[:labels].instance_of?(String)
-        config[:annotations] = JSON[config[:annotations]] if config[:annotations] && config[:annotations].instance_of?(String)
+        config[:public_ips] = config[:public_ips].split(',') if config[:public_ips]
 
         nodepool_properties = {
           name: config[:name],
-          k8s_version: config[:k8s_version],
+          k8s_version: config[:version],
           datacenter_id: config[:datacenter_id],
           node_count: config[:node_count],
           cpu_family: config[:cpu_family],
@@ -138,29 +127,62 @@ class Chef
           storage_type: config[:storage_type],
           storage_size: config[:storage_size],
           public_ips: config[:public_ips],
-          labels: config[:labels],
-          annotations: config[:annotations],
-          lans: config.key?(:lans) ? config[:lans].map! { |lan| { id: Integer(lan) } } : nil,
-          auto_scaling: Ionoscloud::KubernetesAutoScaling.new(
-            min_node_count: config[:min_node_count],
-            max_node_count: config[:max_node_count],
-          ),
-          maintenance_window: (config.key?(:maintenance_day) || config.key?(:maintenance_time)) ? Ionoscloud::KubernetesMaintenanceWindow.new(
-            day_of_the_week: config[:maintenance_day],
-            time: config[:maintenance_time],
-          ) : nil,
         }
 
-        print_k8s_nodepool(
-          kubernetes_api.k8s_nodepools_post(
-            config[:cluster_id],
-            Ionoscloud::KubernetesNodePoolForPost.new(
-              properties: Ionoscloud::KubernetesNodePoolPropertiesForPost.new(
-                **nodepool_properties,
-              ),
-            ),
-          ),
-        )
+        if config[:maintenance_day] && config[:maintenance_time]
+          nodepool_properties[:maintenance_window] = Ionoscloud::KubernetesMaintenanceWindow.new(
+            day_of_the_week: config[:maintenance_day],
+            time: config[:maintenance_time],
+          )
+        end
+
+        if config[:min_node_count] || config[:max_node_count]
+          nodepool_properties[:auto_scaling] = Ionoscloud::KubernetesAutoScaling.new()
+          nodepool_properties[:auto_scaling].min_node_count = config[:min_node_count] unless config[:min_node_count].nil?
+          nodepool_properties[:auto_scaling].max_node_count = config[:max_node_count] unless config[:max_node_count].nil?
+        end
+
+        if config[:lans]
+          nodepool_properties[:lans] = config[:lans].split(',').map! { |lan| { id: Integer(lan) } }
+        end
+
+        nodepool = Ionoscloud::KubernetesNodePool.new(properties: Ionoscloud::KubernetesNodePoolPropertiesForPost.new(nodepool_properties))
+
+        nodepool = kubernetes_api.k8s_nodepools_post(config[:cluster_id], nodepool)
+
+        auto_scaling = "Min node count: #{nodepool.properties.auto_scaling.min_node_count}, Max node count:#{nodepool.properties.auto_scaling.max_node_count}"
+        maintenance_window = "#{nodepool.properties.maintenance_window.day_of_the_week}, #{nodepool.properties.maintenance_window.time}"
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{nodepool.id}"
+        puts "#{ui.color('Name', :cyan)}: #{nodepool.properties.name}"
+        puts "#{ui.color('K8s Version', :cyan)}: #{nodepool.properties.k8s_version}"
+        puts "#{ui.color('Datacenter ID', :cyan)}: #{nodepool.properties.datacenter_id}"
+        puts "#{ui.color('Node Count', :cyan)}: #{nodepool.properties.node_count}"
+        puts "#{ui.color('CPU Family', :cyan)}: #{nodepool.properties.cpu_family}"
+        puts "#{ui.color('Cores Count', :cyan)}: #{nodepool.properties.cores_count}"
+        puts "#{ui.color('RAM', :cyan)}: #{nodepool.properties.ram_size}"
+        puts "#{ui.color('Storage Type', :cyan)}: #{nodepool.properties.storage_type}"
+        puts "#{ui.color('Storage Size', :cyan)}: #{nodepool.properties.storage_size}"
+        puts "#{ui.color('Lans', :cyan)}: #{nodepool.properties.lans.map do
+          |lan|
+          {
+            id: lan.id,
+            dhcp: lan.dhcp,
+            routes: lan.routes ? lan.routes.map do
+              |route|
+              {
+                network: route.network,
+                gateway_ip: route.gateway_ip,
+              }
+            end : []
+          }
+        end}"
+        puts "#{ui.color('Availability Zone', :cyan)}: #{nodepool.properties.availability_zone}"
+        puts "#{ui.color('Auto Scaling', :cyan)}: #{auto_scaling}"
+        puts "#{ui.color('Maintenance Window', :cyan)}: #{maintenance_window}"
+        puts "#{ui.color('State', :cyan)}: #{nodepool.metadata.state}"
+        puts 'done'
       end
     end
   end

data/lib/chef/knife/ionoscloud_nodepool_delete.rb

@@ -23,7 +23,6 @@ class Chef
 
       def run
         $stdout.sync = true
-        handle_extra_config
         validate_required_params(@required_options, config)
 
         kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
@@ -37,7 +36,38 @@ class Chef
             next
           end
 
-          print_k8s_nodepool(nodepool)
+          auto_scaling = "Min node count: #{nodepool.properties.auto_scaling.min_node_count}, Max node count:#{nodepool.properties.auto_scaling.max_node_count}"
+          maintenance_window = "#{nodepool.properties.maintenance_window.day_of_the_week}, #{nodepool.properties.maintenance_window.time}"
+
+          msg_pair('ID', nodepool.id)
+          msg_pair('Name', nodepool.properties.name)
+          msg_pair('K8s Version', nodepool.properties.k8s_version)
+          msg_pair('Datacenter ID', nodepool.properties.datacenter_id)
+          msg_pair('Node Count', nodepool.properties.node_count)
+          msg_pair('CPU Family', nodepool.properties.cpu_family)
+          msg_pair('Cores Count', nodepool.properties.cores_count)
+          msg_pair('RAM', nodepool.properties.ram_size)
+          msg_pair('Storage Type', nodepool.properties.storage_type)
+          msg_pair('Storage Size', nodepool.properties.storage_size)
+          msg_pair('Lans', nodepool.properties.lans.map do
+            |lan|
+            {
+              id: lan.id,
+              dhcp: lan.dhcp,
+              routes: lan.routes ? lan.routes.map do
+                |route|
+                {
+                  network: route.network,
+                  gateway_ip: route.gateway_ip,
+                }
+              end : []
+            }
+          end)
+          msg_pair('Availability Zone', nodepool.properties.availability_zone)
+          msg_pair('Auto Scaling', auto_scaling)
+          msg_pair('Maintenance Window', maintenance_window)
+          msg_pair('State', nodepool.metadata.state)
+
           puts "\n"
 
           begin

data/lib/chef/knife/ionoscloud_nodepool_lan_add.rb

@@ -0,0 +1,130 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNodepoolLanAdd < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud nodepool lan add (options)'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'ID of the Kubernetes cluster'
+
+      option :nodepool_id,
+              short: '-N NODEPOOL_ID',
+              long: '--nodepool NODEPOOL_ID',
+              description: 'The ID of the K8s Nodepool'
+
+      option :lan_id,
+              short: '-L LAN_ID',
+              long: '--lan LAN_ID',
+              description: 'The ID of the LAN'
+
+      option :no_dhcp,
+              long: '--nodhcp',
+              boolean: true,
+              default: false,
+              description: 'Indicates if the Kubernetes Node Pool LAN will reserve an IP using DHCP'
+
+      option :routes,
+              long: '--routes NETWORK,GATEWAY_IP [NETWORK,GATEWAY_IP]',
+              description: 'An array of additional LANs attached to worker nodes'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Adds or updates a LAN within a Nodepool.'
+        @required_options = [:cluster_id, :nodepool_id, :lan_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
+
+        begin
+          nodepool = kubernetes_api.k8s_nodepools_find_by_id(config[:cluster_id], config[:nodepool_id])
+        rescue Ionoscloud::ApiError => err
+          raise err unless err.code == 404
+          ui.error("Nodepool ID #{config[:nodepool_id]} not found.")
+          exit(1)
+        end
+
+        routes = []
+        config[:routes] = config[:routes].split(',') if config[:routes]
+        config[:routes].each_slice(2) do |network, gateway_ip|
+          routes << Ionoscloud::KubernetesNodePoolLanRoutes.new(
+            network: network,
+            gateway_ip: gateway_ip,
+          )
+        end
+
+        new_lan = Ionoscloud::KubernetesNodePoolLan.new(
+          id: Integer(config[:lan_id]),
+          dhcp: !config[:no_dhcp],
+          routes: routes,
+        )
+
+        puts new_lan
+
+        existing = nodepool.properties.lans.select { |lan| lan.id == new_lan.id }
+
+        new_nodepool = Ionoscloud::KubernetesNodePool.new(
+          properties: Ionoscloud::KubernetesNodePoolPropertiesForPut.new(
+            node_count: nodepool.properties.node_count,
+            k8s_version: nodepool.properties.k8s_version,
+            maintenance_window: nodepool.properties.maintenance_window,
+            auto_scaling: nodepool.properties.auto_scaling,
+            public_ips: nodepool.properties.public_ips,
+            lans: nodepool.properties.lans,
+          ),
+        )
+
+        new_nodepool.properties.lans = new_nodepool.properties.lans.delete_if { |lan| lan.id == new_lan.id }
+        new_nodepool.properties.lans << new_lan
+
+        nodepool = kubernetes_api.k8s_nodepools_put(
+          config[:cluster_id], config[:nodepool_id], new_nodepool,
+        )
+
+        if existing.length > 0
+          ui.info("Updating Lan #{config[:lan_id]} in the Nodepoool.")
+        else
+          ui.info("Adding Lan #{config[:lan_id]} to the Nodepoool.")
+        end
+
+        auto_scaling = "Min node count: #{nodepool.properties.auto_scaling.min_node_count}, Max node count:#{nodepool.properties.auto_scaling.max_node_count}"
+        maintenance_window = "#{nodepool.properties.maintenance_window.day_of_the_week}, #{nodepool.properties.maintenance_window.time}"
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{nodepool.id}"
+        puts "#{ui.color('Name', :cyan)}: #{nodepool.properties.name}"
+        puts "#{ui.color('K8s Version', :cyan)}: #{nodepool.properties.k8s_version}"
+        puts "#{ui.color('Node Count', :cyan)}: #{nodepool.properties.node_count}"
+        puts "#{ui.color('Lans', :cyan)}: #{nodepool.properties.lans.map do
+          |lan|
+          {
+            id: lan.id,
+            dhcp: lan.dhcp,
+            routes: lan.routes ? lan.routes.map do
+              |route|
+              {
+                network: route.network,
+                gateway_ip: route.gateway_ip,
+              }
+            end : []
+          }
+        end}"
+        puts "#{ui.color('Auto Scaling', :cyan)}: #{auto_scaling}"
+        puts "#{ui.color('Maintenance Window', :cyan)}: #{maintenance_window}"
+        puts "#{ui.color('State', :cyan)}: #{nodepool.metadata.state}"
+        puts 'done'
+      end
+    end
+  end
+end