knife-ionoscloud 6.1.0 → 6.2.0

data/lib/chef/knife/ionoscloud_applicationloadbalancer_update.rb

@@ -0,0 +1,96 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudApplicationloadbalancerUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud applicationloadbalancer update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :application_loadbalancer_id,
+              short: '-L APPLICATION_LOADBALANCER_ID',
+              long: '--application-loadbalancer APPLICATION_LOADBALANCER_ID',
+              description: 'ID of the Application Loadbalancer'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the Application 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 Application 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 Application 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 Application LoadBalancer.'
+        @directory = 'application-loadbalancer'
+        @required_options = [:datacenter_id, :application_loadbalancer_id]
+        @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)
+
+        application_load_balancers_api = Ionoscloud::ApplicationLoadBalancersApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Application LoadBalancer...', :magenta)}"
+
+          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)
+
+          _, _, headers  = application_load_balancers_api.datacenters_applicationloadbalancers_patch_with_http_info(
+            config[:datacenter_id],
+            config[:application_loadbalancer_id],
+            Ionoscloud::ApplicationLoadBalancerProperties.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_application_loadbalancer(
+          application_load_balancers_api.datacenters_applicationloadbalancers_find_by_application_load_balancer_id(
+            config[:datacenter_id], config[:application_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_backupunit_create.rb

@@ -27,7 +27,7 @@ class Chef
         @description =
         'Create a new backup unit.'
         @directory = 'backup'
-        @required_options = [:name, :password, :email, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:name, :password, :email]
       end
 
       def run

data/lib/chef/knife/ionoscloud_backupunit_delete.rb

@@ -15,7 +15,6 @@ class Chef
         'plans inside a backup unit, ALL backups associated with the backup unit, the '\
         'backup user and finally the backup unit itself.'
         @directory = 'backup'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run
@@ -39,7 +38,7 @@ class Chef
 
           begin
             confirm('Do you really want to delete this Backup unit')
-          rescue SystemExit => exc
+          rescue SystemExit
             next
           end
 

data/lib/chef/knife/ionoscloud_backupunit_get.rb

@@ -17,7 +17,7 @@ class Chef
         @description =
         'Retrieves information about a backup unit.'
         @directory = 'backup'
-        @required_options = [:backupunit_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:backupunit_id]
       end
 
       def run

data/lib/chef/knife/ionoscloud_backupunit_list.rb

@@ -12,7 +12,6 @@ class Chef
         @description =
         'Retrieve a list of all the backup units the supplied credentials have access to.'
         @directory = 'backup'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run

data/lib/chef/knife/ionoscloud_backupunit_ssourl.rb

@@ -19,7 +19,7 @@ class Chef
         'a backup unit, you can access the GUI with a Single Sign On \(SSO\) URL that can be '\
         'retrieved from the Cloud API using this request.'
         @directory = 'backup'
-        @required_options = [:backupunit_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:backupunit_id]
       end
 
       def run

data/lib/chef/knife/ionoscloud_backupunit_update.rb

@@ -26,7 +26,7 @@ class Chef
         @description =
         'Retrieves information about a backup unit.'
         @directory = 'backup'
-        @required_options = [:backupunit_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:backupunit_id]
         @updatable_fields = [:email, :password]
       end
 
@@ -40,7 +40,7 @@ class Chef
         if @updatable_fields.map { |el| config[el] }.any?
           print "#{ui.color('Updating Backup unit...', :magenta)}"
 
-          backupunit, _, headers  = backupunit_api.backupunits_patch_with_http_info(
+          _, _, headers  = backupunit_api.backupunits_patch_with_http_info(
             config[:backupunit_id],
             Ionoscloud::BackupUnitProperties.new(
               password: config[:password],

data/lib/chef/knife/ionoscloud_base.rb

@@ -37,6 +37,10 @@ class Chef
                   long: '--password PASSWORD',
                   description: 'Your Ionoscloud password'
 
+          option :ionoscloud_token,
+                  long: '--token PASSWORD',
+                  description: 'Your Ionoscloud access token'
+
           option :ionoscloud_url,
                   long: '--url URL',
                   description: 'The Ionoscloud API URL'
@@ -49,12 +53,15 @@ class Chef
       end
 
       def msg_pair(label, value, color = :cyan)
-        if !value.nil? && !value.to_s.empty?
-          puts "#{ui.color(label, color)}: #{value}"
-        end
+        puts "#{ui.color(label, color)}: #{value}" if !value.nil? && !value.to_s.empty?
       end
 
       def validate_required_params(required_params, params)
+        if !params[:ionoscloud_token] && !(params[:ionoscloud_username] && params[:ionoscloud_password])
+          puts 'Either ionoscloud_token or ionoscloud_username and ionoscloud_password must be provided to access the Ionoscloud API.'
+          exit(1)
+        end
+
         missing_params = required_params.select do |param|
           params[param].nil?
         end
@@ -75,7 +82,7 @@ class Chef
           if config.key?(key) || !ionoscloud_options.include?(key)
             ignored_options << key
           else
-            config[key] = value 
+            config[key] = value
           end
         end
 
@@ -87,8 +94,12 @@ class Chef
 
         api_config = Ionoscloud::Configuration.new()
 
-        api_config.username = config[:ionoscloud_username]
-        api_config.password = config[:ionoscloud_password]
+        if config[:ionoscloud_token]
+          api_config.token = config[:ionoscloud_token]
+        else
+          api_config.username = config[:ionoscloud_username]
+          api_config.password = config[:ionoscloud_password]
+        end
 
         if config[:ionoscloud_url]
           uri = URI.parse(config[:ionoscloud_url])
@@ -103,7 +114,7 @@ class Chef
 
         @api_client = Ionoscloud::ApiClient.new(api_config)
 
-        @api_client.user_agent =  [
+        @api_client.user_agent = [
           'knife/v' + MODULE_VERSION,
           @api_client.default_headers['User-Agent'],
           'chef/' + Chef::VERSION,
@@ -117,14 +128,18 @@ class Chef
 
         api_config_dbaas = IonoscloudDbaasPostgres::Configuration.new()
 
-        api_config_dbaas.username = config[:ionoscloud_username]
-        api_config_dbaas.password = config[:ionoscloud_password]
+        if config[:ionoscloud_token]
+          api_config_dbaas.token = config[:ionoscloud_token]
+        else
+          api_config_dbaas.username = config[:ionoscloud_username]
+          api_config_dbaas.password = config[:ionoscloud_password]
+        end
 
         api_config_dbaas.debugging = config[:ionoscloud_debug] || false
 
         @api_client_dbaas = IonoscloudDbaasPostgres::ApiClient.new(api_config_dbaas)
 
-        @api_client_dbaas.user_agent =  [
+        @api_client_dbaas.user_agent = [
           'knife/v' + MODULE_VERSION,
           @api_client_dbaas.default_headers['User-Agent'],
           'chef/' + Chef::VERSION,
@@ -150,6 +165,51 @@ class Chef
         response.metadata.status == 'DONE'
       end
 
+      def get_target_group_extended_properties(target_group)
+        health_check = target_group.properties.health_check.nil? ? nil : {
+          check_timeout: target_group.properties.health_check.check_timeout,
+          connect_timeout: target_group.properties.health_check.connect_timeout,
+          target_timeout: target_group.properties.health_check.target_timeout,
+          retries: target_group.properties.health_check.retries,
+        }
+        http_health_check = target_group.properties.http_health_check.nil? ? nil : {
+          path: target_group.properties.http_health_check.path,
+          method: target_group.properties.http_health_check.method,
+          match_type: target_group.properties.http_health_check.match_type,
+          response: target_group.properties.http_health_check.response,
+          regex: target_group.properties.http_health_check.regex,
+          negate: target_group.properties.http_health_check.negate,
+        }
+        targets = target_group.properties.targets.nil? ? [] : target_group.properties.targets.map do |target|
+          {
+            ip: target.ip,
+            port: target.port,
+            weight: target.weight,
+            health_check: target.health_check.nil? ? nil : {
+              check: target.health_check.check,
+              check_interval: target.health_check.check_interval,
+              maintenance: target.health_check.maintenance,
+            },
+          }
+        end
+
+        return health_check, http_health_check, targets
+      end
+
+      def print_target_group(target_group)
+        health_check, http_health_check, targets = get_target_group_extended_properties(target_group)
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{target_group.id}"
+        puts "#{ui.color('Name', :cyan)}: #{target_group.properties.name}"
+        puts "#{ui.color('Algorithm', :cyan)}: #{target_group.properties.algorithm}"
+        puts "#{ui.color('Protocol', :cyan)}: #{target_group.properties.protocol}"
+        puts "#{ui.color('Health Check', :cyan)}: #{health_check}"
+        puts "#{ui.color('HTTP Health Check', :cyan)}: #{http_health_check}"
+        puts "#{ui.color('Targets', :cyan)}: #{targets}"
+        puts 'done'
+      end
+
       def print_datacenter(datacenter)
         print "\n"
         cpu_architecture = datacenter.properties.cpu_architecture.nil? ? [] : datacenter.properties.cpu_architecture.map { |arch| arch.to_hash }
@@ -452,14 +512,104 @@ class Chef
         puts "#{ui.color('Flowlogs', :cyan)}: #{natgateway.entities.flowlogs.items.map { |flowlog| flowlog.id }}"
       end
 
+      def get_application_loadbalancer_extended_properties(application_loadbalancer)
+        fw_rules = application_loadbalancer.entities.forwardingrules.items
+        fw_rules.nil? ? [] : fw_rules.map do |rule|
+          {
+            id: rule.id,
+            name: rule.properties.name,
+            protocol: rule.properties.protocol,
+            listener_ip: rule.properties.listener_ip,
+            listener_port: rule.properties.listener_port,
+            client_timeout: rule.properties.client_timeout,
+            server_certificates: rule.properties.server_certificates,
+            http_rules: rule.properties.http_rules.nil? ? [] : rule.properties.http_rules.map do |http_rule|
+              {
+                name: http_rule.name,
+                type: http_rule.type,
+                target_group: http_rule.target_group,
+                drop_query: http_rule.drop_query,
+                location: http_rule.location,
+                status_code: http_rule.status_code,
+                response_message: http_rule.response_message,
+                content_type: http_rule.content_type,
+                conditions: http_rule.conditions.nil? ? [] : http_rule.conditions.map do |condition|
+                  {
+                    type: condition.type,
+                    condition: condition.condition,
+                    negate: condition.negate,
+                    key: condition.key,
+                    value: condition.value,
+                  }
+                end,
+              }
+            end,
+          }
+        end
+      end
+
+      def print_application_loadbalancer(application_loadbalancer)
+        rules = get_application_loadbalancer_extended_properties(application_loadbalancer)
+
+        print "\n"
+        puts "#{ui.color('ID', :cyan)}: #{application_loadbalancer.id}"
+        puts "#{ui.color('Name', :cyan)}: #{application_loadbalancer.properties.name}"
+        puts "#{ui.color('Listener LAN', :cyan)}: #{application_loadbalancer.properties.listener_lan}"
+        puts "#{ui.color('Target LAN', :cyan)}: #{application_loadbalancer.properties.target_lan}"
+        puts "#{ui.color('IPS', :cyan)}: #{application_loadbalancer.properties.ips}"
+        puts "#{ui.color('Lb Private IPS', :cyan)}: #{application_loadbalancer.properties.lb_private_ips}"
+        puts "#{ui.color('Rules', :cyan)}: #{rules}"
+      end
+
+      def get_target_group_extended_properties(target_group)
+        health_check = target_group.properties.health_check.nil? ? nil : {
+          check_timeout: target_group.properties.health_check.check_timeout,
+          check_interval: target_group.properties.health_check.check_interval,
+          retries: target_group.properties.health_check.retries,
+        }
+        http_health_check = target_group.properties.http_health_check.nil? ? nil : {
+          path: target_group.properties.http_health_check.path,
+          method: target_group.properties.http_health_check.method,
+          match_type: target_group.properties.http_health_check.match_type,
+          response: target_group.properties.http_health_check.response,
+          regex: target_group.properties.http_health_check.regex,
+          negate: target_group.properties.http_health_check.negate,
+        }
+        targets = target_group.properties.targets.nil? ? [] : target_group.properties.targets.map do |target|
+          {
+            ip: target.ip,
+            port: target.port,
+            weight: target.weight,
+            health_check_enabled: target.health_check_enabled,
+            maintenance_enabled: target.maintenance_enabled,
+          }
+        end
+
+        return health_check, http_health_check, targets
+      end
+
+      def print_target_group(target_group)
+        health_check, http_health_check, targets = get_target_group_extended_properties(target_group)
+        print "\n"
+        puts "#{ui.color('ID', :cyan)}: #{target_group.id}"
+        puts "#{ui.color('Name', :cyan)}: #{target_group.properties.name}"
+        puts "#{ui.color('Algorithm', :cyan)}: #{target_group.properties.algorithm}"
+        puts "#{ui.color('Protocol', :cyan)}: #{target_group.properties.protocol}"
+        puts "#{ui.color('Health Check', :cyan)}: #{health_check}"
+        puts "#{ui.color('HTTP Health Check', :cyan)}: #{http_health_check}"
+        puts "#{ui.color('Targets', :cyan)}: #{targets}"
+        puts 'done'
+      end
+
       def print_cluster(cluster)
         connections = cluster.properties.connections.map { |connection| connection.to_hash }
-        
+
         print "\n"
         puts "#{ui.color('ID', :cyan)}: #{cluster.id}"
         puts "#{ui.color('Display Name', :cyan)}: #{cluster.properties.display_name}"
         puts "#{ui.color('Postgres Version', :cyan)}: #{cluster.properties.postgres_version}"
         puts "#{ui.color('Location', :cyan)}: #{cluster.properties.location}"
+        puts "#{ui.color('Backup location', :cyan)}: #{cluster.properties.backup_location}"
         puts "#{ui.color('Instances', :cyan)}: #{cluster.properties.instances}"
         puts "#{ui.color('RAM Size', :cyan)}: #{cluster.properties.ram}"
         puts "#{ui.color('Cores', :cyan)}: #{cluster.properties.cores}"

data/lib/chef/knife/ionoscloud_composite_server_create.rb

@@ -130,7 +130,7 @@ class Chef
         'This creates a new composite server with an attached volume and NIC in a specified virtual data center.'
         @directory = 'compute-engine'
         @required_options = [
-          :datacenter_id, :name, :cores, :ram, :size, :type, :dhcp, :lan, :ionoscloud_username, :ionoscloud_password,
+          :datacenter_id, :name, :cores, :ram, :size, :type, :dhcp, :lan,
         ]
       end
 
@@ -158,7 +158,7 @@ class Chef
             availability_zone: config[:volume_availability_zone],
             backupunit_id: config[:backupunit_id],
             user_data: config[:user_data],
-          }.compact)
+          }.compact),
         )
 
         nic = Ionoscloud::Nic.new(
@@ -168,7 +168,7 @@ class Chef
             dhcp: config[:dhcp],
             lan: config[:lan],
             firewall_type: config[:firewall_type],
-          }.compact)
+          }.compact),
         )
 
         server = Ionoscloud::Server.new(

data/lib/chef/knife/ionoscloud_contract_list.rb

@@ -12,7 +12,6 @@ class Chef
         @description =
         'Lists information about available contract resources.'
         @directory = 'user'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run
@@ -22,8 +21,7 @@ class Chef
 
         contracts = Ionoscloud::ContractResourcesApi.new(api_client).contracts_get()
 
-        contracts.items.each do
-          |contract|
+        contracts.items.each do |contract|
           puts "#{ui.color('Contract Type', :cyan)}: #{contract.type}"
           puts "#{ui.color('Contract Owner', :cyan)}: #{contract.properties.owner}"
           puts "#{ui.color('Contract Number', :cyan)}: #{contract.properties.contract_number}"

data/lib/chef/knife/ionoscloud_cube_server_create.rb

@@ -110,7 +110,7 @@ class Chef
         'This creates a new cube server with an attached volume and NIC in a specified virtual data center.'
         @directory = 'compute-engine'
         @required_options = [
-          :datacenter_id, :name, :template, :ionoscloud_username, :ionoscloud_password,
+          :datacenter_id, :name, :template,
         ]
       end
 
@@ -135,7 +135,7 @@ class Chef
             licence_type: config[:licence_type],
             backupunit_id: config[:backupunit_id],
             user_data: config[:user_data],
-          }.compact)
+          }.compact),
         )]
 
         nics = []
@@ -149,8 +149,8 @@ class Chef
                 dhcp: config[:dhcp],
                 lan: config[:lan],
                 firewall_type: config[:firewall_type],
-              }.compact)
-            )
+              }.compact),
+            ),
           ]
         end
 

data/lib/chef/knife/ionoscloud_datacenter_create.rb

@@ -25,13 +25,13 @@ class Chef
       def initialize(args = [])
         super(args)
         @description =
-        "Unless you are planning to manage an existing Ionoscloud environment, "\
-        "the first step will typically involve choosing the location for a new virtual data center"\
+        'Unless you are planning to manage an existing Ionoscloud environment, '\
+        'the first step will typically involve choosing the location for a new virtual data center'\
         "A list of locations can be obtained with location command.\n\n\t"\
         "```text\nknife ionoscloud location list\n```\n\n"\
         "Make a note of the desired location ID and now the data center can be created.\n"
         @directory = 'compute-engine'
-        @required_options = [:location, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:location]
       end
 
       def run

data/lib/chef/knife/ionoscloud_datacenter_delete.rb

@@ -14,7 +14,6 @@ class Chef
         'all objects contained within that data center -- servers, volumes, snapshots, and so on. '\
         'The objects -- once removed -- will be unrecoverable.'
         @directory = 'compute-engine'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run
@@ -38,7 +37,7 @@ class Chef
 
           begin
             confirm('Do you really want to delete this data center')
-          rescue SystemExit => exc
+          rescue SystemExit
             next
           end
 

data/lib/chef/knife/ionoscloud_datacenter_get.rb

@@ -17,7 +17,7 @@ class Chef
         @description =
         'Retrieves information about a Ionoscloud Datacenter.'
         @directory = 'compute-engine'
-        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:datacenter_id]
       end
 
       def run

data/lib/chef/knife/ionoscloud_datacenter_list.rb

@@ -17,7 +17,6 @@ class Chef
         'experience as you would have if you were running your own physical '\
         'data center. A list of available data centers can be obtained with the following command.'
         @directory = 'compute-engine'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run

data/lib/chef/knife/ionoscloud_datacenter_update.rb

@@ -30,7 +30,7 @@ class Chef
         @description =
         'Updates information about a Ionoscloud Datacenter.'
         @directory = 'compute-engine'
-        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:datacenter_id]
         @updatable_fields = [:name, :description, :sec_auth_protection]
       end
 
@@ -44,13 +44,13 @@ class Chef
         if @updatable_fields.map { |el| config[el] }.any?
           print "#{ui.color('Updating data center...', :magenta)}"
 
-          datacenter, _, headers  = datacenter_api.datacenters_patch_with_http_info(
+          _, _, headers  = datacenter_api.datacenters_patch_with_http_info(
             config[:datacenter_id],
             Ionoscloud::DatacenterProperties.new(
               name: config[:name],
               description: config[:description],
               sec_auth_protection: (config.key?(:sec_auth_protection) ? config[:sec_auth_protection].to_s.downcase == 'true' : nil),
-            )
+            ),
           )
 
           dot = ui.color('.', :magenta)

data/lib/chef/knife/ionoscloud_dbaas_postgres_backup_get.rb

@@ -15,10 +15,10 @@ class Chef
       def initialize(args = [])
         super(args)
         @description =
-        'Retrieve a PostgreSQL cluster backup by using its ID. This value can be
-        found when you GET a list of PostgreSQL cluster backups.'
+        'Retrieve a PostgreSQL cluster backup by using its ID. This value can be '\
+        'found when you GET a list of PostgreSQL cluster backups.'
         @directory = 'dbaas-postgres'
-        @required_options = [:backup_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:backup_id]
       end
 
       def run

data/lib/chef/knife/ionoscloud_dbaas_postgres_backup_list.rb

@@ -15,10 +15,9 @@ class Chef
       def initialize(args = [])
         super(args)
         @description =
-        'If cluster_id is provided, retrieves a list of all backups of the given PostgreSQL cluster,
-        otherwise retrieves a list of all PostgreSQL cluster backups.'
+        'If cluster_id is provided, retrieves a list of all backups of the given PostgreSQL cluster, '\
+        'otherwise retrieves a list of all PostgreSQL cluster backups.'
         @directory = 'dbaas-postgres'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 
       def run

data/lib/chef/knife/ionoscloud_dbaas_postgres_cluster_create.rb

@@ -45,6 +45,10 @@ class Chef
                             be where all of your instances live. Property cannot be modified
                             after datacenter creation (disallowed in update requests)'
 
+      option :backup_location,
+              long: '--backup-location BACKUP_LOCATION',
+              description: 'The S3 location where the backups will be stored.'
+
       option :display_name,
               short: '-n DISPLAY_NAME',
               long: '--name DISPLAY_NAME',
@@ -67,7 +71,7 @@ class Chef
       option  :synchronization_mode,
                short: '-s SYNCHRONIZATION_MODE',
                long: '--synchronization-mode SYNCHRONIZATION_MODE',
-               description: 'Represents different modes of replication'
+               description: 'Represents different modes of replication. One of [ASYNCHRONOUS, SYNCHRONOUS, STRICTLY_SYNCHRONOUS]'
 
       option :username,
               long: '--db-user DB_USERNAME',
@@ -91,13 +95,13 @@ class Chef
       def initialize(args = [])
         super(args)
         @description =
-        'Creates a new PostgreSQL cluster.
-        If the `fromBackup` field is populated, the new cluster will be created
-        based on the given backup.'
+        'Creates a new PostgreSQL cluster. '\
+        'If the `fromBackup` field is populated, the new cluster will be created '\
+        'based on the given backup.'
         @directory = 'dbaas-postgres'
         @required_options = [
           :postgres_version, :instances, :cores, :ram, :storage_size, :storage_type,
-          :connections, :location, :display_name, :synchronization_mode, :username, :password, :ionoscloud_username, :ionoscloud_password,
+          :connections, :location, :display_name, :synchronization_mode, :username, :password,
         ]
       end
 
@@ -110,8 +114,7 @@ class Chef
 
         config[:connections] = JSON[config[:connections]] if config[:connections] && config[:connections].instance_of?(String)
 
-        config[:connections] = config[:connections].map do
-          |connection|
+        config[:connections] = config[:connections].map do |connection|
           IonoscloudDbaasPostgres::Connection.new(
             datacenter_id: connection['datacenter_id'],
             lan_id: String(connection['lan_id']),
@@ -130,6 +133,7 @@ class Chef
           storage_type: config[:storage_type],
           connections: config[:connections],
           location: config[:location],
+          backup_location: config[:backup_location],
           display_name: config[:display_name],
           maintenance_window: (config[:time] && config[:day_of_the_week]) ? IonoscloudDbaasPostgres::MaintenanceWindow.new(
             time: config[:time],
@@ -149,7 +153,7 @@ class Chef
         cluster_request = IonoscloudDbaasPostgres::CreateClusterRequest.new()
         cluster_request.properties = cluster_properties
 
-        cluster, _, headers  = clusters_api.clusters_post_with_http_info(cluster_request)
+        cluster, _, _  = clusters_api.clusters_post_with_http_info(cluster_request)
 
         print_cluster(cluster)
       end