knife-ionoscloud 5.1.1 → 6.0.0.beta.2

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_target_add.rb

@@ -0,0 +1,124 @@
+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
+        handle_extra_config
+        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 }
+
+        print_network_load_balancer(
+          network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_target_list.rb

@@ -0,0 +1,70 @@
+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
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        $stdout.sync = true
+        handle_extra_config
+        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

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_target_remove.rb

@@ -0,0 +1,88 @@
+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
+        handle_extra_config
+        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
+
+        print_network_load_balancer(
+          network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_update.rb

@@ -0,0 +1,148 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerRuleUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer rule update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: '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'
+
+      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'
+
+      option :protocol,
+              long: '--protocol PROTOCOL',
+              description: 'Protocol of the balancing'
+
+      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.'
+
+      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.'
+
+      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.'
+
+      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])'
+
+      option :targets,
+              long: '--targets TARGETS',
+              description: 'Array of targets'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Network Load Balancer.'
+        @required_options = [:datacenter_id, :network_loadbalancer_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [
+          :name, :algorithm, :protocol, :listener_ip, :listener_port, :targets,
+          :client_timeout, :connect_timeout, :target_timeout, :retries,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        network_load_balancer_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+
+        config[:gateway_ips] = config[:gateway_ips].split(',') if config[:gateway_ips] && config[:gateway_ips].instance_of?(String)
+        config[:targets] = JSON[config[:targets]] if config[:targets] && config[:targets].instance_of?(String)
+
+        config[:targets] = config[:targets].map do
+          |target|
+          Ionoscloud::NetworkLoadBalancerForwardingRuleTarget.new(
+            ip: target['ip'],
+            port: target['port'],
+            weight: target['weight'],
+            health_check: Ionoscloud::NetworkLoadBalancerForwardingRuleTargetHealthCheck.new(
+              check: target['health_check']['check'],
+              check_interval: target['health_check']['check_interval'],
+              maintenance: target['health_check']['maintenance'],
+            ),
+          )
+        end if config[:targets]
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Network Load Balancer...', :magenta)}"
+
+          _, _, headers  = network_load_balancer_api.datacenters_networkloadbalancers_forwardingrules_patch_with_http_info(
+            config[:datacenter_id],
+            config[:network_loadbalancer_id],
+            config[:forwarding_rule_id],
+            Ionoscloud::NetworkLoadBalancerForwardingRuleProperties.new(
+              name: config[:name],
+              algorithm: config[:algorithm],
+              protocol: config[:protocol],
+              listener_ip: config[:listener_ip],
+              listener_port: config[:listener_port],
+              targets: config[:targets],
+              health_check: Ionoscloud::NetworkLoadBalancerForwardingRuleHealthCheck.new(
+                client_timeout: config[:client_timeout],
+                connect_timeout: config[:connect_timeout],
+                target_timeout: config[:target_timeout],
+                retries: config[:retries],
+              ),
+            ),
+          )
+
+          dot = ui.color('.', :magenta)
+          api_client.wait_for { print dot; is_done? get_request_id headers }
+        else
+          ui.warn("Nothing to update, please set one of the attributes #{@updatable_fields}.")
+        end
+
+        print_network_load_balancer(
+          network_load_balancer_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_update.rb

@@ -0,0 +1,98 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: '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 :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the load balancer'
+
+      option :listener_lan,
+              short: '-l LISTENER_LAN_ID',
+              long: '--listener-lan LISTENER_LAN_ID',
+              description: 'Id of the listening LAN. (inbound)'
+
+      option :target_lan,
+              short: '-t TARGET_LAN_ID',
+              long: '--target-lan TARGET_LAN_ID',
+              description: 'Id of the balanced private target LAN. (outbound)'
+
+      option :ips,
+              short: '-i IP[,IP,...]',
+              long: '--ips IP[,IP,...]',
+              description: 'Collection of IP addresses of the Network Load Balancer. (inbound and outbound) '\
+                          'IP of the listenerLan must be a customer reserved IP for the public load balancer '\
+                          'and private IP for the private load balancer.'
+
+      option :lb_private_ips,
+              long: '--private-ips IP[,IP,...]',
+              description: 'Collection of private IP addresses with subnet mask of the Network Load Balancer. '\
+                          'IPs must contain valid subnet mask. If user will not provide any IP then the system '\
+                          'will generate one IP with /24 subnet.'
+
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Network Load Balancer.'
+        @required_options = [:datacenter_id, :network_loadbalancer_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [:name, :listener_lan, :target_lan, :ips, :lb_private_ips]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        config[:ips] = config[:ips].split(',') if config[:ips] && config[:ips].instance_of?(String)
+        config[:lb_private_ips] = config[:lb_private_ips].split(',') if config[:lb_private_ips] && config[:lb_private_ips].instance_of?(String)
+
+        network_load_balancer_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Network Load Balancer...', :magenta)}"
+
+          _, _, headers  = network_load_balancer_api.datacenters_networkloadbalancers_patch_with_http_info(
+            config[:datacenter_id],
+            config[:network_loadbalancer_id],
+            Ionoscloud::NetworkLoadBalancerProperties.new({
+              name: config[:name],
+              ips: config[:ips],
+              listener_lan: config[:listener_lan],
+              target_lan: config[:target_lan],
+              lb_private_ips: config[:lb_private_ips],
+            }.compact),
+          )
+
+          dot = ui.color('.', :magenta)
+          api_client.wait_for { print dot; is_done? get_request_id headers }
+        else
+          ui.warn("Nothing to update, please set one of the attributes #{@updatable_fields}.")
+        end
+
+        print_network_load_balancer(
+          network_load_balancer_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_nic_create.rb

@@ -39,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',
-              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
 
@@ -62,40 +65,32 @@ class Chef
 
         config[:ips] = config[:ips].split(',') if config[:ips] && config[:ips].instance_of?(String)
 
-        params = {
+        nic_properties = {
           name: config[:name],
           ips: config[:ips],
           dhcp: config[:dhcp],
           lan: config[:lan],
-          nat: !config[:nat].nil?,
-        }
+          firewall_type: config[:firewall_type]
+        }.compact
 
-        nic_api = Ionoscloud::NicApi.new(api_client)
+        nic_api = Ionoscloud::NetworkInterfacesApi.new(api_client)
 
         nic, _, headers = nic_api.datacenters_servers_nics_post_with_http_info(
           config[:datacenter_id],
           config[:server_id],
-          { properties: params.compact },
+          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 }
 
-        nic = nic_api.datacenters_servers_nics_find_by_id(
-          config[:datacenter_id],
-          config[:server_id],
-          nic.id,
+        print_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('NAT', :cyan)}: #{nic.properties.nat}"
-
-        puts 'done'
       end
     end
   end

data/lib/chef/knife/ionoscloud_nic_delete.rb

@@ -31,7 +31,7 @@ class Chef
         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)
@@ -41,12 +41,8 @@ class Chef
             next
           end
 
-          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('NAT', nic.properties.nat)
+          print_nic(nic)
+          puts "\n"
 
           begin
             confirm('Do you really want to delete this Nic')

data/lib/chef/knife/ionoscloud_nic_get.rb

@@ -0,0 +1,49 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNicGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud nic get (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server to which the NIC is assigned'
+
+      option :nic_id,
+              short: '-N NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'ID of the load balancer'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves the attributes of a given NIC.'
+        @required_options = [:datacenter_id, :server_id, :nic_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_nic(
+          Ionoscloud::NetworkInterfacesApi.new(api_client).datacenters_servers_nics_find_by_id(
+            config[:datacenter_id],
+            config[:server_id],
+            config[:nic_id],
+          ),
+        )
+      end
+    end
+  end
+end