knife-ionoscloud 6.0.0.alpha.1 → 6.1.0

data/lib/chef/knife/ionoscloud_group_update.rb

@@ -0,0 +1,130 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudGroupUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud group update (options)'
+
+      option :group_id,
+              short: '-G GROUP_ID',
+              long: '--group-id GROUP_ID',
+              description: 'ID of the group.'
+
+      option :name,
+              short: '-N NAME',
+              long: '--name NAME',
+              description: 'Mame of the group.'
+
+      option :create_data_center,
+              short: '-D CREATE_DATACENTER',
+              long: '--create-datacenter CREATE_DATACENTER',
+              description: 'The group will be allowed to create virtual data centers.'
+
+      option :create_snapshot,
+              short: '-s CREATE_SNAPSHOT',
+              long: '--create-snapshot CREATE_SNAPSHOT',
+              description: 'The group will be allowed to create snapshots.'
+
+      option :reserve_ip,
+              short: '-i RESERVE_IP',
+              long: '--reserve-ip RESERVE_IP',
+              description: 'The group will be allowed to reserve IP addresses.'
+
+      option :access_activity_log,
+              short: '-a ACCESS_ACTIVITY_LOG',
+              long: '--access-log ACCESS_ACTIVITY_LOG',
+              description: 'The group will be allowed to access the activity log.'
+
+      option :s3_privilege,
+              long: '--s3 S3_PRIVILEGE',
+              description: 'The group will be allowed to manage S3'
+
+      option :create_backup_unit,
+              short: '-b CREATE_BACKUPUNIT',
+              long: '--create-backupunit CREATE_BACKUPUNIT',
+              description: 'The group will be able to manage backup units.'
+
+      option :create_k8s_cluster,
+              long: '--create-k8s-cluster CREATE_K8S_CLUSTER',
+              description: 'The group will be able to create kubernetes clusters.'
+
+      option :create_pcc,
+              long: '--create-pcc CREATE_PCC',
+              description: 'The group will be able to manage pccs.'
+
+      option :create_internet_access,
+              long: '--create-internet-access CREATE_INTERNET_ACCESS',
+              description: 'The group will be have internet access privilege.'
+
+      option :create_flow_log,
+              long: '--create-flow-log CREATE_FLOW_LOG',
+              description: 'The group will be granted create Flow Logs privilege.'
+
+      option :access_and_manage_monitoring,
+              long: '--manage-monitoring ACCESS_AND_MANAGE_MONITORING',
+              description: 'Privilege for a group to access and manage monitoring '\
+              'related functionality (access metrics, CRUD on alarms, alarm-actions etc) using Monotoring-as-a-Service (MaaS).'
+
+      option :access_and_manage_certificates,
+              long: '--manage-certificates ACCESS_AND_MANAGE_CERTIFICATES',
+              description: 'Privilege for a group to access and manage certificates.'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Group.'
+        @directory = 'user'
+        @required_options = [:group_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [
+          :name, :create_data_center, :create_snapshot, :reserve_ip, :access_activity_log, :s3_privilege,
+          :create_backup_unit, :create_k8s_cluster, :create_pcc, :create_internet_access,
+          :create_flow_log, :access_and_manage_monitoring, :access_and_manage_certificates,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        user_management_api = Ionoscloud::UserManagementApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Group...', :magenta)}"
+
+          existing_group = user_management_api.um_groups_find_by_id(config[:group_id], depth: 1)
+
+          group, _, headers = user_management_api.um_groups_put_with_http_info(
+            config[:group_id],
+            Ionoscloud::Group.new(
+              properties: Ionoscloud::GroupProperties.new(
+                name: config[:name] || existing_group.properties.name,
+                create_data_center: config.key?(:create_data_center) ? config[:create_data_center].to_s != 'false' : existing_group.properties.create_data_center,
+                create_snapshot: config.key?(:create_snapshot) ? config[:create_snapshot].to_s != 'false' : existing_group.properties.create_snapshot,
+                reserve_ip: config.key?(:reserve_ip) ? config[:reserve_ip].to_s != 'false' : existing_group.properties.reserve_ip,
+                access_activity_log: config.key?(:access_activity_log) ? config[:access_activity_log].to_s != 'false' : existing_group.properties.access_activity_log,
+                s3_privilege: config.key?(:s3_privilege) ? config[:s3_privilege].to_s != 'false' : existing_group.properties.s3_privilege,
+                create_backup_unit: config.key?(:create_backup_unit) ? config[:create_backup_unit].to_s != 'false' : existing_group.properties.create_backup_unit,
+                create_k8s_cluster: config.key?(:create_k8s_cluster) ? config[:create_k8s_cluster].to_s != 'false' : existing_group.properties.create_k8s_cluster,
+                create_pcc: config.key?(:create_pcc) ? config[:create_pcc].to_s != 'false' : existing_group.properties.create_pcc,
+                create_internet_access: config.key?(:create_internet_access) ? config[:create_internet_access].to_s != 'false' : existing_group.properties.create_internet_access,
+                create_flow_log: config.key?(:create_flow_log) ? config[:create_flow_log].to_s != 'false' : existing_group.properties.create_flow_log,
+                access_and_manage_monitoring: config.key?(:access_and_manage_monitoring) ? config[:access_and_manage_monitoring].to_s != 'false' : existing_group.properties.access_and_manage_monitoring,
+                access_and_manage_certificates: config.key?(:access_and_manage_certificates) ? config[:access_and_manage_certificates].to_s != 'false' : existing_group.properties.access_and_manage_certificates,
+              ),
+            ),
+          )
+
+          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_group(user_management_api.um_groups_find_by_id(config[:group_id], depth: 1))
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_group_user_add.rb

@@ -12,17 +12,17 @@ class Chef
               long: '--group-id GROUP_ID',
               description: 'ID of the group.'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Use this operation to add an existing user to a group.'
+        @directory = 'user'
         @required_options = [:group_id, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         user_management_api = Ionoscloud::UserManagementApi.new(api_client)
@@ -48,24 +48,7 @@ class Chef
 
         request_ids_to_wait.each { |request_id| api_client.wait_for { is_done? request_id } }
 
-        group = user_management_api.um_groups_find_by_id(
-          config[:group_id],
-          { depth: 1 },
-        )
-
-        users = group.entities.users.items.map! { |el| el.id }
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{group.id}"
-        puts "#{ui.color('Name', :cyan)}: #{group.properties.name}"
-        puts "#{ui.color('Create Datacenter', :cyan)}: #{group.properties.create_data_center.to_s}"
-        puts "#{ui.color('Create Snapshot', :cyan)}: #{group.properties.create_snapshot.to_s}"
-        puts "#{ui.color('Reserve IP', :cyan)}: #{group.properties.reserve_ip.to_s}"
-        puts "#{ui.color('Access Activity Log', :cyan)}: #{group.properties.access_activity_log.to_s}"
-        puts "#{ui.color('S3 Privilege', :cyan)}: #{group.properties.s3_privilege.to_s}"
-        puts "#{ui.color('Create Backup Unit', :cyan)}: #{group.properties.create_backup_unit.to_s}"
-        puts "#{ui.color('Users', :cyan)}: #{users.to_s}"
-        puts 'done'
+        print_group(user_management_api.um_groups_find_by_id(config[:group_id], depth: 1))
       end
     end
   end

data/lib/chef/knife/ionoscloud_group_user_remove.rb

@@ -12,17 +12,17 @@ class Chef
               long: '--group-id GROUP_ID',
               description: 'ID of the group.'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Use this operation to remove a user from a group.'
+        @directory = 'user'
         @required_options = [:group_id, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         user_management_api = Ionoscloud::UserManagementApi.new(api_client)
@@ -48,24 +48,7 @@ class Chef
 
         request_ids_to_wait.each { |request_id| api_client.wait_for { is_done? request_id } }
 
-        group = user_management_api.um_groups_find_by_id(
-          config[:group_id],
-          { depth: 1 },
-        )
-
-        users = group.entities.users.items.map! { |el| el.id }
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{group.id}"
-        puts "#{ui.color('Name', :cyan)}: #{group.properties.name}"
-        puts "#{ui.color('Create Datacenter', :cyan)}: #{group.properties.create_data_center.to_s}"
-        puts "#{ui.color('Create Snapshot', :cyan)}: #{group.properties.create_snapshot.to_s}"
-        puts "#{ui.color('Reserve IP', :cyan)}: #{group.properties.reserve_ip.to_s}"
-        puts "#{ui.color('Access Activity Log', :cyan)}: #{group.properties.access_activity_log.to_s}"
-        puts "#{ui.color('S3 Privilege', :cyan)}: #{group.properties.s3_privilege.to_s}"
-        puts "#{ui.color('Create Backup Unit', :cyan)}: #{group.properties.create_backup_unit.to_s}"
-        puts "#{ui.color('Users', :cyan)}: #{users.to_s}"
-        puts 'done'
+        print_group(user_management_api.um_groups_find_by_id(config[:group_id], depth: 1))
       end
     end
   end

data/lib/chef/knife/ionoscloud_image_list.rb

@@ -7,18 +7,18 @@ class Chef
 
       banner 'knife ionoscloud image list'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'A list of disk and ISO images are available from Ionoscloud for immediate use. '\
         'Make sure the image you use is in the same location as the virtual data center.'
+        @directory = 'compute-engine'
         @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         image_list = [

data/lib/chef/knife/ionoscloud_ipblock_create.rb

@@ -22,8 +22,6 @@ class Chef
               long: '--name NAME',
               description: 'Name of the IP block'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
@@ -31,32 +29,31 @@ class Chef
         'within any VDCs provisioned in that same location. An IP block consists of '\
         'one or more static IP addresses. The IP block size \(number of IP addresses\) '\
         'and location are required to reserve an IP block.'
+        @directory = 'compute-engine'
         @required_options = [:size, :location, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         print "#{ui.color('Allocating IP block...', :magenta)}"
 
-        params = {
-          location: config[:location],
-          size: config[:size],
-          name: config[:name],
-        }.compact
-
-        ipblock, _, headers = Ionoscloud::IPBlocksApi.new(api_client).ipblocks_post_with_http_info({ properties: params.compact })
+        ipblock, _, headers = Ionoscloud::IPBlocksApi.new(api_client).ipblocks_post_with_http_info(
+          Ionoscloud::IpBlock.new(
+            properties: Ionoscloud::IpBlockProperties.new(
+              location: config[:location],
+              size: config[:size],
+              name: config[:name],
+            ),
+          ),
+        )
 
         dot = ui.color('.', :magenta)
         api_client.wait_for { print dot; is_done? get_request_id headers }
 
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{ipblock.id}"
-        puts "#{ui.color('Name', :cyan)}: #{ipblock.properties.name}"
-        puts "#{ui.color('Location', :cyan)}: #{ipblock.properties.location}"
-        puts "#{ui.color('IP Addresses', :cyan)}: #{ipblock.properties.ips.to_s}"
-        puts 'done'
+        print_ipblock(ipblock)
       end
     end
   end

data/lib/chef/knife/ionoscloud_ipblock_delete.rb

@@ -7,17 +7,17 @@ class Chef
 
       banner 'knife ionoscloud ipblock delete IPBLOCK_ID [IPBLOCK_ID]'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Releases a currently assigned IP block.'
+        @directory = 'compute-engine'
         @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         ipblock_api = Ionoscloud::IPBlocksApi.new(api_client)
@@ -30,10 +30,7 @@ class Chef
             next
           end
 
-          msg_pair('ID', ipblock.id)
-          msg_pair('Name', ipblock.properties.name)
-          msg_pair('Location', ipblock.properties.location)
-          msg_pair('IP Addresses', ipblock.properties.ips)
+          print_ipblock(ipblock)
 
           begin
             confirm('Do you really want to delete this IP block')

data/lib/chef/knife/ionoscloud_ipblock_get.rb

@@ -0,0 +1,32 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudIpblockGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud ipblock get (options)'
+
+      option :ipblock_id,
+              short: '-I IPBLOCK_ID',
+              long: '--ipblock-id IPBLOCK_ID',
+              description: 'ID of the IPBlock.'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves information about an IP Block.'
+        @directory = 'compute-engine'
+        @required_options = [:ipblock_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_ipblock(Ionoscloud::IPBlocksApi.new(api_client).ipblocks_find_by_id(config[:ipblock_id]))
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_ipblock_list.rb

@@ -7,17 +7,17 @@ class Chef
 
       banner 'knife ionoscloud ipblock list'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Lists all available IP blocks.'
+        @directory = 'compute-engine'
         @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         ipblock_list = [

data/lib/chef/knife/ionoscloud_ipblock_update.rb

@@ -0,0 +1,56 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudIpblockUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud ipblock update (options)'
+
+      option :ipblock_id,
+              short: '-I IPBLOCK_ID',
+              long: '--ipblock-id IPBLOCK_ID',
+              description: 'ID of the IPBlock.'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the IP block'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about an IP Block.'
+        @directory = 'compute-engine'
+        @required_options = [:ipblock_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [:name]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        ipblock_api = Ionoscloud::IPBlocksApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating IP block...', :magenta)}"
+
+          _, _, headers  = ipblock_api.ipblocks_patch_with_http_info(
+            config[:ipblock_id],
+            Ionoscloud::IpBlockProperties.new(
+              name: config[:name],
+            ),
+          )
+
+          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_ipblock(ipblock_api.ipblocks_find_by_id(config[:ipblock_id]))
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_ipfailover_add.rb

@@ -27,8 +27,6 @@ class Chef
               long: '--nic-id NIC_ID',
               description: 'NIC to be added to IP failover group'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
@@ -36,14 +34,16 @@ class Chef
         "* Add a reserved IP address to a NIC that will become the IP Failover master.\n"\
         "* Use PATCH or PUT to enable ipFailover by providing the relevant ip and nicUuid values.\n"\
         "* Add the same reserved IP address to any other NICs that are a member of the same LAN. Those NICs will become IP Failover members.\n"
+        @directory = 'compute-engine'
         @required_options = [:datacenter_id, :lan_id, :ip, :nic_id, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
-        lan_api = Ionoscloud::LansApi.new(api_client)
+        lan_api = Ionoscloud::LANsApi.new(api_client)
 
         lan = lan_api.datacenters_lans_find_by_id(config[:datacenter_id], config[:lan_id])
 

data/lib/chef/knife/ionoscloud_ipfailover_remove.rb

@@ -27,20 +27,20 @@ class Chef
               long: '--nic-id NIC_ID',
               description: 'NIC to be removed from the IP failover group'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Remove IP Failover from LAN'
+        @directory = 'compute-engine'
         @required_options = [:datacenter_id, :lan_id, :ip, :nic_id, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
-        lan_api = Ionoscloud::LansApi.new(api_client)
+        lan_api = Ionoscloud::LANsApi.new(api_client)
 
         lan = lan_api.datacenters_lans_find_by_id(config[:datacenter_id], config[:lan_id])
 

data/lib/chef/knife/ionoscloud_k8s_create.rb

@@ -17,15 +17,6 @@ class Chef
               long: '--version VERSION',
               description: 'The version for the Kubernetes cluster.'
 
-      option :private,
-              long: '--private',
-              default: false,
-              description: 'The indicator if the cluster is public or private. Be aware that setting it to false is currently in beta phase.'
-
-      option :gateway_ip,
-              long: '--gateway GATEWAY_IP',
-              description: 'The IP address of the gateway used by the cluster. This is mandatory when `public` is set to `false` and should not be provided otherwise.'
-
       option :maintenance_day,
               short: '-d MAINTENANCE_DAY',
               long: '--maintenance-day MAINTENANCE_DAY',
@@ -36,61 +27,62 @@ class Chef
               long: '--maintenance-time MAINTENANCE_TIME',
               description: 'Time Of the day when to perform the maintenance.'
 
-      attr_reader :description, :required_options
+      option :api_subnet_allow_list,
+              long: '--subnets SUBNET [SUBNET]',
+              description: 'Access to the K8s API server is restricted to these CIDRs. Cluster-internal traffic is not affected by this restriction. '\
+              'If no allowlist is specified, access is not restricted. If an IP without subnet mask is provided, the default value will be used: 32 '\
+              'for IPv4 and 128 for IPv6.'
+
+      option :s3_buckets,
+              long: '--buckets S3_BUCKET [S3_BUCKET]',
+              description: 'List of S3 bucket configured for K8s usage. For now it contains only an S3 bucket used to store K8s API audit logs'
 
       def initialize(args = [])
         super(args)
         @description =
         'Creates a new Managed Kubernetes cluster.'
+        @directory = 'kubernetes'
         @required_options = [:name, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         print "#{ui.color('Creating K8s Cluster...', :magenta)}"
 
         kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
 
+        config[:api_subnet_allow_list] = config[:api_subnet_allow_list].split(',') if config[:api_subnet_allow_list] && config[:api_subnet_allow_list].instance_of?(String)
+        config[:s3_buckets] = config[:s3_buckets].split(',') if config[:s3_buckets] && config[:s3_buckets].instance_of?(String)
+
         cluster_properties = {
           name: config[:name],
-          k8sVersion: config[:version],
-          public: !config[:private],
+          k8s_version: config[:version],
+          api_subnet_allow_list: config[:api_subnet_allow_list],
+          s3_buckets: (config[:s3_buckets].nil? ? config[:s3_buckets] : config[:s3_buckets].map { |el| Ionoscloud::S3Bucket.new(name: el) }),
         }.compact
 
-        if config[:private]
-          if !config[:gateway_ip]
-            ui.error("Gateway IP must be specified for private K8s Clusters")
-            exit(1)
-          end
-          cluster_properties[:gatewayIp] = config[:gateway_ip]
-        end
-
         if config[:maintenance_day] && config[:maintenance_time]
-          cluster_properties[:maintenanceWindow] = {
-            dayOfTheWeek: config[:maintenance_day],
+          cluster_properties[:maintenance_window] = Ionoscloud::KubernetesMaintenanceWindow.new(
+            day_of_the_week: config[:maintenance_day],
             time: config[:maintenance_time],
-          }
+          )
         end
 
-        cluster, _, headers = kubernetes_api.k8s_post_with_http_info({ properties: cluster_properties })
+        k8s_cluster = Ionoscloud::KubernetesClusterForPost.new(
+          properties: Ionoscloud::KubernetesClusterPropertiesForPost.new(
+            **cluster_properties,
+          ),
+        )
+
+        cluster, _, headers = kubernetes_api.k8s_post_with_http_info(k8s_cluster)
 
         dot = ui.color('.', :magenta)
         api_client.wait_for { print dot; is_done? get_request_id headers }
 
-        cluster = kubernetes_api.k8s_find_by_cluster_id(cluster.id)
-
-        maintenance_window = "#{cluster.properties.maintenance_window.day_of_the_week}, #{cluster.properties.maintenance_window.time}"
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{cluster.id}"
-        puts "#{ui.color('Name', :cyan)}: #{cluster.properties.name}"
-        puts "#{ui.color('k8s Version', :cyan)}: #{cluster.properties.k8s_version}"
-        puts "#{ui.color('Maintenance Window', :cyan)}: #{maintenance_window}"
-        puts "#{ui.color('State', :cyan)}: #{cluster.metadata.state}"
-
-        puts 'done'
+        print_k8s_cluster(kubernetes_api.k8s_find_by_cluster_id(cluster.id))
       end
     end
   end

data/lib/chef/knife/ionoscloud_k8s_delete.rb

@@ -7,17 +7,17 @@ class Chef
 
       banner 'knife ionoscloud k8s delete CLUSTER_ID [CLUSTER_ID]'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Deletes a Kubernetes cluster. The cluster cannot contain any node pools when deleting.'
+        @directory = 'kubernetes'
         @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
@@ -44,15 +44,7 @@ class Chef
             next
           end
 
-          msg_pair('ID', cluster.id)
-          msg_pair('Name', cluster.properties.name)
-          msg_pair('Version', cluster.properties.k8s_version)
-          msg_pair(
-            'Maintenance Window',
-            "#{cluster.properties.maintenance_window.day_of_the_week}, #{cluster.properties.maintenance_window.time}",
-          )
-          msg_pair('State', cluster.metadata.state)
-
+          print_k8s_cluster(cluster)
           puts "\n"
 
           begin

data/lib/chef/knife/ionoscloud_k8s_get.rb

@@ -0,0 +1,32 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudK8sGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud k8s get (options)'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'ID of the Kubernetes cluster'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves information about a K8s Cluster.'
+        @directory = 'kubernetes'
+        @required_options = [:cluster_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_k8s_cluster(Ionoscloud::KubernetesApi.new(api_client).k8s_find_by_cluster_id(config[:cluster_id]))
+      end
+    end
+  end
+end