knife-ionoscloud 5.1.2 → 6.0.0.alpha.1

data/lib/chef/knife/ionoscloud_networkloadbalancer_delete.rb

@@ -0,0 +1,81 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerDelete < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer delete LOAD_BALANCER_ID [LOAD_BALANCER_ID] (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Removes the specified Network Load Balancer.'
+        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        network_load_balancers_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+
+        @name_args.each do |network_load_balancer_id|
+          begin
+            network_load_balancer = network_load_balancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+              config[:datacenter_id],
+              network_load_balancer_id,
+              { depth: 1 },
+            )
+          rescue Ionoscloud::ApiError => err
+            raise err unless err.code == 404
+            ui.error("Network Load balancer ID #{network_load_balancer_id} not found. Skipping.")
+            next
+          end
+
+          msg_pair('ID', network_load_balancer.id)
+          msg_pair('Name', network_load_balancer.properties.name)
+          msg_pair('Listener LAN', network_load_balancer.properties.listener_lan)
+          msg_pair('IPS', network_load_balancer.properties.ips)
+          msg_pair('Target LAN', network_load_balancer.properties.target_lan)
+          msg_pair('Private IPS', network_load_balancer.properties.lb_private_ips)
+          msg_pair('Forwarding Rules', network_load_balancer.entities.forwardingrules.items.map do |rule|
+              {
+                id: rule.id,
+                name: rule.properties.name,
+                algorithm: rule.properties.algorithm,
+                protocol: rule.properties.protocol,
+                listener_ip: rule.properties.listener_ip,
+                listener_port: rule.properties.listener_port,
+                health_check: rule.properties.health_check,
+                targets: rule.properties.targets,
+              }
+            end
+          )
+          # msg_pair('Flowlogs', network_load_balancer.entities.flowlogs.items.map { |flowlog| flowlog.id })
+
+          puts "\n"
+
+          begin
+            confirm('Do you really want to delete this Network Load balancer')
+          rescue SystemExit => exc
+            next
+          end
+
+          _, _, headers = network_load_balancers_api.datacenters_networkloadbalancers_delete_with_http_info(
+            config[:datacenter_id],
+            network_load_balancer_id,
+          )
+          ui.warn("Deleted Network Load balancer #{network_load_balancer.id}. Request ID: #{get_request_id headers}")
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_list.rb

@@ -0,0 +1,56 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer list (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieve a list of Network Load Balancers within the datacenter.'
+        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        network_load_balancers_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Listener LAN', :bold),
+          ui.color('Target LAN', :bold),
+          ui.color('Rules', :bold),
+          ui.color('Flowlogs', :bold),
+          ui.color('IPS', :bold),
+          ui.color('Private IPS', :bold),
+        ]
+
+        network_load_balancers_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+
+        network_load_balancers_api.datacenters_networkloadbalancers_get(config[:datacenter_id], { depth: 2 }).items.each do |network_load_balancer|
+          network_load_balancers_list << network_load_balancer.id
+          network_load_balancers_list << network_load_balancer.properties.name
+          network_load_balancers_list << network_load_balancer.properties.listener_lan
+          network_load_balancers_list << network_load_balancer.properties.target_lan
+          network_load_balancers_list << network_load_balancer.entities.forwardingrules.items.length
+          network_load_balancers_list << network_load_balancer.entities.flowlogs.items.length
+          network_load_balancers_list << network_load_balancer.properties.ips
+          network_load_balancers_list << network_load_balancer.properties.lb_private_ips
+        end
+
+        puts ui.list(network_load_balancers_list, :uneven_columns_across, 8)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_add.rb

@@ -0,0 +1,150 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerRuleAdd < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer rule add (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 :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'A name of that Network Load Balancer forwarding rule'
+
+      option :algorithm,
+              short: '-a ALGORITHM',
+              long: '--algorithm ALGORITHM',
+              description: 'Algorithm for the balancing',
+              default: 'ROUND_ROBIN'
+
+      option :protocol,
+              long: '--protocol PROTOCOL',
+              description: 'Protocol of the balancing',
+              default: 'TCP'
+
+      option :listener_ip,
+              short: '-i LISTENER_IP',
+              long: '--ip LISTENER_IP',
+              description: 'Listening IP. (inbound)'
+
+      option :listener_port,
+              short: '-p LISTENER_PORT',
+              long: '--port LISTENER_PORT',
+              description: 'Listening port number. (inbound) (range: 1 to 65535)'
+
+      option :client_timeout,
+              long: '--client-timeout CLIENT_TIMEOUT',
+              description: 'ClientTimeout is expressed in milliseconds. This inactivity timeout applies when '\
+              'the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.',
+              default: 50
+
+      option :check_timeout,
+              long: '--check-timeout CLIENT_TIMEOUT',
+              description: 'It specifies the time (in milliseconds) for a target VM in this pool to answer the check. '\
+              'If a target VM has CheckInterval set and CheckTimeout is set too, then the smaller value of the two is '\
+              'used after the TCP connection is established.',
+              default: 2000
+
+      option :connect_timeout,
+              long: '--connect-timeout CONNECT_TIMEOUT',
+              description: 'It specifies the maximum time (in milliseconds) to wait for a connection attempt to a '\
+              'target VM to succeed. If unset, the default of 5 seconds will be used.',
+              default: 5000
+
+      option :target_timeout,
+              long: '--terget-timeout TARGET_TIMEOUT',
+              description: 'TargetTimeout specifies the maximum inactivity time (in milliseconds) on the target VM side. '\
+              'If unset, the default of 50 seconds will be used.',
+              default: 50000
+
+      option :retries,
+              short: '-r RETRIES',
+              long: '--retries RETRIES',
+              description: 'Retries specifies the number of retries to perform on a target VM after a connection failure. '\
+              'If unset, the default value of 3 will be used. (valid range: [0, 65535])',
+              default: 3
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Adds a Forwarding Rule to a Network Load Balancer under a data center.'
+        @required_options = [:datacenter_id, :network_loadbalancer_id, :name, :listener_ip, :listener_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)
+
+        if config[:gateway_ips]
+          config[:gateway_ips] = config[:gateway_ips].split(',')
+        end
+
+        network_loadbalancer_forwarding_rule = Ionoscloud::NetworkLoadBalancerForwardingRule.new(
+          properties: Ionoscloud::NetworkLoadBalancerForwardingRuleProperties.new(
+            name: config[:name],
+            algorithm: config[:algorithm],
+            protocol: config[:protocol],
+            listener_ip: config[:listener_ip],
+            listener_port: config[:listener_port],
+            health_check: Ionoscloud::NetworkLoadBalancerForwardingRuleHealthCheck.new(
+              client_timeout: config[:client_timeout],
+              check_timeout: config[:check_timeout],
+              connect_timeout: config[:connect_timeout],
+              target_timeout: config[:target_timeout],
+              retries: config[:retries],
+            ),
+          ),
+        )
+
+        _, _, headers = network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_post_with_http_info(
+          config[:datacenter_id], config[:network_loadbalancer_id], network_loadbalancer_forwarding_rule,
+        )
+
+        print "#{ui.color('Adding the rule to the Network Loadbalancer...', :magenta)}"
+        dot = ui.color('.', :magenta)
+        api_client.wait_for { print dot; is_done? get_request_id headers }
+
+        network_load_balancer = network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+          config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+        )
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{network_load_balancer.id}"
+        puts "#{ui.color('Name', :cyan)}: #{network_load_balancer.properties.name}"
+        puts "#{ui.color('Listener LAN', :cyan)}: #{network_load_balancer.properties.listener_lan}"
+        puts "#{ui.color('IPS', :cyan)}: #{network_load_balancer.properties.ips}"
+        puts "#{ui.color('Target LAN', :cyan)}: #{network_load_balancer.properties.target_lan}"
+        puts "#{ui.color('Private IPS', :cyan)}: #{network_load_balancer.properties.lb_private_ips}"
+        puts "#{ui.color('Forwarding Rules', :cyan)}: #{network_load_balancer.entities.forwardingrules.items.map do |rule|
+          {
+            id: rule.id,
+            name: rule.properties.name,
+            algorithm: rule.properties.algorithm,
+            protocol: rule.properties.protocol,
+            listener_ip: rule.properties.listener_ip,
+            listener_port: rule.properties.listener_port,
+            health_check: rule.properties.health_check,
+            targets: rule.properties.targets,
+          }
+        end}"
+        puts "#{ui.color('Flowlogs', :cyan)}: #{network_load_balancer.entities.flowlogs.items.map { |flowlog| flowlog.id }}"
+        puts 'done'
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_list.rb

@@ -0,0 +1,63 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerRuleList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer rule list (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID 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'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Lists all available rules in a Network Loadbalancer under a data center.'
+        @required_options = [:datacenter_id, :network_loadbalancer_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        $stdout.sync = true
+        network_loadbalancer_rule_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Algorithm', :bold),
+          ui.color('Protocol', :bold),
+          ui.color('Listener IP', :bold),
+          ui.color('Listener Port', :bold),
+          ui.color('Targets', :bold),
+          ui.color('Health Check', :bold),
+        ]
+        network_loadbalancers_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+
+        network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_get(
+          config[:datacenter_id], config[:network_loadbalancer_id], depth: 1,
+        ).items.each do |network_loadbalancer_rule|
+          network_loadbalancer_rule_list << network_loadbalancer_rule.id
+          network_loadbalancer_rule_list << network_loadbalancer_rule.properties.name
+          network_loadbalancer_rule_list << network_loadbalancer_rule.properties.algorithm
+          network_loadbalancer_rule_list << network_loadbalancer_rule.properties.protocol
+          network_loadbalancer_rule_list << network_loadbalancer_rule.properties.listener_ip
+          network_loadbalancer_rule_list << network_loadbalancer_rule.properties.listener_port
+          network_loadbalancer_rule_list << network_loadbalancer_rule.properties.targets.length
+          network_loadbalancer_rule_list << network_loadbalancer_rule.properties.health_check
+        end
+
+        puts ui.list(network_loadbalancer_rule_list, :uneven_columns_across, 8)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_remove.rb

@@ -0,0 +1,78 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerRuleRemove < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer rule remove RULE_ID [RULE_ID] (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID 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'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Removes the specified rules from a Network Loadbalancer under a data center.'
+        @required_options = [:datacenter_id, :network_loadbalancer_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        return unless @name_args.length > 0
+
+        network_loadbalancers_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+
+        headers_to_wait = []
+        @name_args.each do |rule_id|
+          _, _, headers = network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_delete_with_http_info(
+            config[:datacenter_id], config[:network_loadbalancer_id], rule_id,
+          )
+          headers_to_wait << headers
+        end
+
+        print "#{ui.color("Removing rules #{@name_args} from the NAT Gateway...", :magenta)}"
+        dot = ui.color('.', :magenta)
+
+        headers_to_wait.each { |headers| api_client.wait_for { print dot; is_done? get_request_id headers } }
+
+        network_load_balancer = network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+          config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+        )
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{network_load_balancer.id}"
+        puts "#{ui.color('Name', :cyan)}: #{network_load_balancer.properties.name}"
+        puts "#{ui.color('Listener LAN', :cyan)}: #{network_load_balancer.properties.listener_lan}"
+        puts "#{ui.color('IPS', :cyan)}: #{network_load_balancer.properties.ips}"
+        puts "#{ui.color('Target LAN', :cyan)}: #{network_load_balancer.properties.target_lan}"
+        puts "#{ui.color('Private IPS', :cyan)}: #{network_load_balancer.properties.lb_private_ips}"
+        puts "#{ui.color('Forwarding Rules', :cyan)}: #{network_load_balancer.entities.forwardingrules.items.map do |rule|
+          {
+            id: rule.id,
+            name: rule.properties.name,
+            algorithm: rule.properties.algorithm,
+            protocol: rule.properties.protocol,
+            listener_ip: rule.properties.listener_ip,
+            listener_port: rule.properties.listener_port,
+            health_check: rule.properties.health_check,
+            targets: rule.properties.targets,
+          }
+        end}"
+        puts "#{ui.color('Flowlogs', :cyan)}: #{network_load_balancer.entities.flowlogs.items.map { |flowlog| flowlog.id }}"
+        puts 'done'
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_target_add.rb

@@ -0,0 +1,141 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerRuleTargetAdd < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer rule target add (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)'
+
+      option :weight,
+              short: '-w WEIGTH',
+              long: '--weight WEIGTH',
+              description: 'Weight parameter is used to adjust the target VM\'s weight relative to other target VMs. '\
+              'All target VMs will receive a load proportional to their weight relative to the sum of all weights, so '\
+              'the higher the weight, the higher the load. The default weight is 1, and the maximal value is 256. A '\
+              'value of 0 means the target VM will not participate in load-balancing but will still accept persistent '\
+              'connections. If this parameter is used to distribute the load according to target VM\'s capacity, it is '\
+              'recommended to start with values which can both grow and shrink, for instance between 10 and 100 to leave '\
+              'enough room above and below for later adjustments.'
+
+      option :check,
+              short: '-c',
+              long: '--check',
+              description: 'Check specifies whether the target VM\'s health is checked. If turned off, a target VM is '\
+              'always considered available. If turned on, the target VM is available when accepting periodic TCP connections, '\
+              'to ensure that it is really able to serve requests. The address and port to send the tests to are those of the '\
+              'target VM. The health check only consists of a connection attempt.',
+              boolean: true
+
+      option :check_interval,
+              long: '--check-interval CHECK_INTERVAL',
+              description: 'CheckInterval determines the duration (in milliseconds) between consecutive health checks. '\
+              'If unspecified a default of 2000 ms is used.',
+              default: 2000
+
+      option :maintenance,
+              short: '-m',
+              long: '--maintenance MAINTENANCE',
+              description: 'Maintenance specifies if a target VM should be marked as down, even if it is not.',
+              boolean: true
+
+      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, :weight, :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],
+        )
+
+        network_loadbalancer_forwarding_rule_target = Ionoscloud::NetworkLoadBalancerForwardingRuleTarget.new(
+          ip: config[:ip],
+          port: config[:port],
+          weight: config[:weight],
+          health_check: Ionoscloud::NetworkLoadBalancerForwardingRuleTargetHealthCheck.new(
+            check: config[:check],
+            check_interval: config[:check_interval],
+            maintenance: config[:maintenance],
+          ),
+        )
+
+        network_load_balancer_rule.properties.targets << network_loadbalancer_forwarding_rule_target
+
+        _, _, 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('Adding the target to the Network Loadbalancer Forwarding Rule...', :magenta)}"
+        dot = ui.color('.', :magenta)
+        api_client.wait_for { print dot; is_done? get_request_id headers }
+
+        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_networkloadbalancer_rule_target_list.rb

@@ -0,0 +1,68 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerRuleTargetList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer rule target list (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID 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'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Lists all targets of a Network Loadbalancer Forwarding Rule under a data center.'
+        @required_options = [
+          :datacenter_id, :network_loadbalancer_id, :forwarding_rule_id, :ionoscloud_username, :ionoscloud_password,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        $stdout.sync = true
+        target_list = [
+          ui.color('IP', :bold),
+          ui.color('Port', :bold),
+          ui.color('Weight', :bold),
+          ui.color('Check', :bold),
+          ui.color('Check interval', :bold),
+          ui.color('Maintenance', :bold),
+        ]
+        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],
+        )
+
+        network_load_balancer_rule.properties.targets.each do |target|
+          target_list << target.ip
+          target_list << target.port
+          target_list << target.weight
+          target_list << target.health_check.check
+          target_list << target.health_check.check_interval
+          target_list << target.health_check.maintenance
+        end
+
+        puts ui.list(target_list, :uneven_columns_across, 6)
+      end
+    end
+  end
+end