cheese-chef-provisioning-azurerm 1.0.7 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f501881562076e732f468745379839590324a30
-  data.tar.gz: 9f2cd2a3ed2fc68ff0d0940b40e6a1f4262b662d
+  metadata.gz: 0bd53a70d8bfd0e4caf6fcc087dc766c4ebd8b09
+  data.tar.gz: 3bb6edada005df509ef2708873a5a5b0ede8617c
 SHA512:
-  metadata.gz: 4e15a311e699d333fe281817b7bfd941c16bbea6e3f9234842a5a5821d4a1da41c1fdd34d2af4adb448544a61fa166ccf27c6f45cdab2e856a8257fe1d72b52d
-  data.tar.gz: bfeaa69e93a5a26eb9fd9386a52abe03996832c3755a04acf818d00cdec6f27afe31570d486286e8b6011a34af1a5069b6df890d247a35b4a1a9083efb828357
+  metadata.gz: 220b6f59eaeb8ea3b7a4f8101017aa29f0687950f4d761464071ad628161cd034273a5832b5315810b59049ae056d534f4ce15bfdf77cf3c076a36d2c7b7ceee
+  data.tar.gz: 51b8efd3b60eaea97451900000f45a137ac238c80038d1460992cebe528a209bc4cecedae4d2cff3c5be26a5eab28b81aeb89ce1cffbb249a14e2dc75b5fa164

data/lib/chef/provider/azure_load_balancer.rb

@@ -0,0 +1,168 @@
+require 'chef/provisioning/azurerm/azure_provider'
+
+class Chef
+  class Provider
+    class AzureLoadBalancer < Chef::Provisioning::AzureRM::AzureProvider
+      provides :azure_load_balancer
+
+      def whyrun_supported?
+        true
+      end
+
+      action :create do
+        create_or_update_load_balancer
+
+        # load_balancer_exists = does_load_balancer_exist
+
+        # if load_balancer_exists
+        #   converge_by("update load balancer #{new_resource.name}") do
+        #     create_or_update_load_balancer
+        #   end
+        # else
+        #   converge_by("create load balancer #{new_resource.name}") do
+        #     create_or_update_load_balancer
+        #   end
+        # end
+      end
+
+      action :destroy do
+        converge_by("destroy load_balancer: #{new_resource.name}") do
+          if does_load_balancer_exist
+            destroy_load_balancer
+          else
+            action_handler.report_progress "load balancer #{new_resource.name} was not found."
+          end
+        end
+      end
+
+      def does_load_balancer_exist
+        try_azure_operation('listing load balancers', true) do
+          network_management_client.load_balancers.get(new_resource.resource_group, new_resource.name)
+        end
+      end
+
+      def destroy_load_balancer
+        action_handler.report_progress 'Destroying Load Balancer...'
+        try_azure_operation('destroying load balancer') do
+          network_management_client.load_balancers.delete(new_resource.resource_group, new_resource.name)
+        end
+      end
+      # #
+
+      def lb_update(lb)
+        network_management_client.load_balancers.create_or_update(new_resource.resource_group, new_resource.name, lb)
+      end
+
+      def create_or_update_load_balancer
+        tags = new_resource.load_balancer_options[:tags]
+        subinfo = network_management_client.subnets.get(new_resource.resource_group, new_resource.virtual_network, new_resource.subnet_name)
+
+        backend_pool = []
+
+        new_resource.virtual_machine.each do |ivm|
+          count = backend_pool.count
+          backend_pool[count] = Azure::ARM::Network::Models::BackendAddressPool.new
+          backend_pool[count].name = ivm
+        end
+
+        frontend_ipconf = Azure::ARM::Network::Models::FrontendIPConfiguration.new.tap do |feip|
+          new_resource.load_balancer_options[:frontend].each do |fendip|
+            feip.name = fendip[:name]
+            feip.subnet = subinfo
+            feip.private_ipallocation_method = fendip[:private_ipallocation_method]
+          end
+        end
+
+        probe = Azure::ARM::Network::Models::Probe.new.tap do |prb|
+          new_resource.load_balancer_options[:probes].each do |prbes|
+            prb.name = prbes[:name]
+            prb.port = prbes[:port]
+            prb.protocol = prbes[:protocol]
+            if prbes[:protocol].casecmp('http')
+              prb.request_path = prbes[:request_path]
+            end
+            prb.interval_in_seconds = prbes[:interval_in_seconds]
+            prb.number_of_probes = prbes[:number_of_probes]
+          end
+        end
+
+        lb = Azure::ARM::Network::Models::LoadBalancer.new.tap do |lbinfo|
+          lbinfo.location = new_resource.location
+          lbinfo.tags = tags
+          lbinfo.frontend_ipconfigurations = [frontend_ipconf]
+          lbinfo.backend_address_pools = backend_pool
+          lbinfo.probes = [probe]
+        end
+
+        lb_update(lb) # inital build
+
+        mylb = network_management_client.load_balancers.get(new_resource.resource_group, new_resource.name)
+
+        new_resource.virtual_machine.each do |ivm|
+          vmnic = network_management_client.network_interfaces.get(new_resource.resource_group, ivm)
+          mylb.backend_address_pools.each do |pool|
+            next unless pool.name == ivm
+            vmnic.ip_configurations.first.load_balancer_backend_address_pools = [pool] # mylb.backend_address_pools
+            network_management_client.network_interfaces.create_or_update(new_resource.resource_group, ivm, vmnic)
+          end
+        end
+
+        frontend_ipconf_sub = MsRestAzure::SubResource.new.tap do |subresource|
+          subresource.id = network_management_client.load_balancers.get(new_resource.resource_group, new_resource.name).frontend_ipconfigurations.first.id
+        end
+
+        backend_ipconf_sub = MsRestAzure::SubResource.new.tap do |subresource|
+          subresource.id = mylb.backend_address_pools.first.id
+        end
+
+        probe_sub = MsRestAzure::SubResource.new.tap do |subresource|
+          subresource.id = network_management_client.load_balancers.get(new_resource.resource_group, new_resource.name).probes.first.id
+        end
+
+        unless new_resource.load_balancer_options[:inboundnat].nil?
+          inboudnat = Azure::ARM::Network::Models::InboundNatRule.new.tap do |inat|
+            new_resource.load_balancer_options[:inboundnat].each do |ibnat|
+              inat.name = ibnat[:name]
+              inat.frontend_port = ibnat[:frontend_port]
+              inat.backend_port = ibnat[:backend_port]
+              inat.protocol = ibnat[:protocol]
+              inat.enable_floating_ip = ibnat[:enable_floating_ip]
+              inat.idle_timeout_in_minutes = ibnat[:idle_timeout_in_minutes]
+              inat.frontend_ipconfiguration = frontend_ipconf_sub
+            end
+          end
+        end
+
+        lbrules = Azure::ARM::Network::Models::LoadBalancingRule.new.tap do |lbrs|
+          new_resource.load_balancer_options[:lbr].each do |lbr|
+            lbrs.name = lbr[:name]
+            lbrs.backend_address_pool = backend_ipconf_sub
+            lbrs.protocol = lbr[:protocol]
+            lbrs.backend_port = lbr[:backend_port]
+            lbrs.frontend_port = lbr[:frontend_port]
+            lbrs.idle_timeout_in_minutes = lbr[:idle_timeout_in_minutes]
+            lbrs.enable_floating_ip = lbr[:enable_floating_ip]
+            lbrs.load_distribution = lbr[:load_distribution]
+            lbrs.frontend_ipconfiguration = frontend_ipconf_sub
+            lbrs.backend_address_pool = backend_ipconf_sub
+            lbrs.probe = probe_sub
+          end
+        end
+
+        lb = Azure::ARM::Network::Models::LoadBalancer.new.tap do |lbinfo|
+          lbinfo.location = new_resource.location
+          lbinfo.tags = tags
+          lbinfo.frontend_ipconfigurations = [frontend_ipconf]
+          lbinfo.backend_address_pools = backend_pool
+          unless new_resource.load_balancer_options[:inboundnat].nil?
+            lbinfo.inbound_nat_rules = [inboudnat]
+          end
+          lbinfo.probes = [probe]
+          lbinfo.load_balancing_rules = [lbrules]
+        end
+
+        lb_update(lb) # update additions build
+      end
+    end # class AzureLoadBalancer
+  end # class Provider
+end # class Chef

data/lib/chef/provisioning/azurerm.rb

@@ -10,7 +10,7 @@ require 'azure_mgmt_network'
 Chef::Log.info("chef-provisioning-azurerm #{Chef::Provisioning::AzureRM::VERSION}")
 Chef::Log.info("chef-provisioning #{Chef::Provisioning::VERSION}")
 
-resources = %w(resource_group resource_template storage_account virtual_network network_interface public_ip_address data_disk)
+resources = %w(resource_group resource_template storage_account virtual_network network_interface public_ip_address data_disk load_balancer)
 resources.each do |r|
   require "chef/resource/azure_#{r}"
   require "chef/provider/azure_#{r}"

data/lib/chef/provisioning/azurerm/azure_provider.rb

@@ -35,7 +35,7 @@ class Chef
 
         def network_management_client
           credentials = Credentials.new.azure_credentials_for_subscription(new_resource.subscription_id)
-          client = Azure::ARM::Network::NetworkResourceProviderClient.new(credentials)
+          client = Azure::ARM::Network::NetworkManagementClient.new(credentials)
           client.subscription_id = new_resource.subscription_id
           client
         end

data/lib/chef/provisioning/azurerm/driver.rb

@@ -1,17 +1,17 @@
-require "chef/mixin/shell_out"
-require "chef/provisioning/driver"
-require "chef/provisioning/convergence_strategy/install_cached"
-require "chef/provisioning/convergence_strategy/install_sh"
-require "chef/provisioning/convergence_strategy/install_msi"
-require "chef/provisioning/convergence_strategy/no_converge"
-require "chef/provisioning/transport/ssh"
-require "chef/provisioning/transport/winrm"
-require "chef/provisioning/machine/windows_machine"
-require "chef/provisioning/machine/unix_machine"
-require "chef/provisioning/machine_spec"
+require 'chef/mixin/shell_out'
+require 'chef/provisioning/driver'
+require 'chef/provisioning/convergence_strategy/install_cached'
+require 'chef/provisioning/convergence_strategy/install_sh'
+require 'chef/provisioning/convergence_strategy/install_msi'
+require 'chef/provisioning/convergence_strategy/no_converge'
+require 'chef/provisioning/transport/ssh'
+require 'chef/provisioning/transport/winrm'
+require 'chef/provisioning/machine/windows_machine'
+require 'chef/provisioning/machine/unix_machine'
+require 'chef/provisioning/machine_spec'
 require 'chef/provisioning/azurerm/azure_provider'
 require 'chef/provisioning/azurerm/credentials'
-require "chef/provisioning/azurerm/version"
+require 'chef/provisioning/azurerm/version'
 require 'chef/provisioning/azurerm/azure_resource'
 
 require 'azure_mgmt_resources'
@@ -38,28 +38,28 @@ class Chef
         end
 
         def self.canonicalize_url(driver_url, config)
-          scheme, account_id = driver_url.split(":", 2)
+          scheme, account_id = driver_url.split(':', 2)
           if account_id.nil? || account_id.empty?
             subscription = Credentials.new
             subscription.azure_credentials_for_subscription(subscription_id)
-            if !subscription
+            unless subscription
               raise "Driver #{driver_url} did not specify a subscription ID, and no default subscription was found.  Have you downloaded the Azure CLI and used `azure account download` and `azure account import` to set up Azure?  Alternately, you can set azure_subscriptions to [ { subscription_id: '...', management_credentials: ... }] in your Chef configuration."
             end
             config = Cheffish::MergedConfig.new({ azure_subscriptions: subscription }, config)
           end
           if subscription
-            [ "#{scheme}:#{subscription[:subscription_id]}", config ]
+            ["#{scheme}:#{subscription[:subscription_id]}", config]
           else
-            [ driver_url, config]
+            [driver_url, config]
           end
         end
 
         def initialize(driver_url, config)
           super
-          scheme, subscription_id = driver_url.split(":", 2)
+          scheme, subscription_id = driver_url.split(':', 2)
           self.subscription_id = subscription_id
           @subscription = Credentials.new.azure_credentials_for_subscription(subscription_id)
-          if !subscription
+          unless subscription
             raise "Driver #{driver_url} has a subscription ID, but the system has no credentials configured for it!  If you have access to this subscription, you can use `azure account download` and `azure account import` in the Azure CLI to get the credentials, or set azure_subscriptions to [ { subscription_id: '...', management_credentials: ... }] in your Chef configuration."
           end
           Chef::Config.chef_provisioning ||= {}
@@ -69,9 +69,7 @@ class Chef
         attr_accessor :subscription_id
 
         def deep_symbolize_keys(hash_like)
-          if hash_like.nil? || hash_like.empty?
-          return {}
-          end
+          return {} if hash_like.nil? || hash_like.empty?
           r = {}
           hash_like.each do |key, value|
             value = deep_symbolize_keys(value) if value.respond_to?(:values)
@@ -100,14 +98,14 @@ class Chef
           osProfile = bootstrap_options[:osProfile]
           network_security_group_name = bootstrap_options[:network_security_group_name]
           tags = bootstrap_options[:tags]
-          raise "location not provided, where the virtual machine should be created" unless location
-          raise "resource_group_name not provided, where the virtual machine should be created" unless resource_group_name
-          raise "osProfile properties not provided in bootstrap_options" unless osProfile
+          raise 'location not provided, where the virtual machine should be created' unless location
+          raise 'resource_group_name not provided, where the virtual machine should be created' unless resource_group_name
+          raise 'osProfile properties not provided in bootstrap_options' unless osProfile
           computerName = osProfile[:computerName]
           adminPassword = osProfile[:adminPassword]
           adminUsername = osProfile[:adminUsername]
           linuxConfiguration = osProfile[:linuxConfiguration]
-          raise "adminUsername under osProfile properties not provided in bootstrap_options" unless adminUsername
+          raise 'adminUsername under osProfile properties not provided in bootstrap_options' unless adminUsername
 
           Chef::Log.debug "Azure machine_options: #{machine_options.inspect}"
           action_handler.report_progress "Creating #{machine_spec.name} in #{location} with supplied parameters..."
@@ -129,7 +127,7 @@ class Chef
           end
           if os_disk_exist
             action_handler.report_progress "OS disk with the name #{vm_name}_os_disk already exist."
-            action_handler.report_progress "checking attached status..."
+            action_handler.report_progress 'checking attached status...'
             if os_disk_exist.owner_id.nil?
               action_handler.report_progress "OS disk #{vm_name} not attached to any VM. Using this..."
               os_disk = Azure::ARM::Compute::Models::OSDisk.new.tap do |os_disk|
@@ -165,7 +163,7 @@ class Chef
           end
           if nic_exist
             action_handler.report_progress "network interface with the name #{vm_name} already exist."
-            action_handler.report_progress "checking attached status..."
+            action_handler.report_progress 'checking attached status...'
             if nic_exist.virtual_machine.nil?
               action_handler.report_progress "network interface #{vm_name} not attached to any VM. Using this..."
               nic = nic_exist
@@ -192,48 +190,54 @@ class Chef
                   end
                 ]
               end
-              )
+            )
           end
 
           vm_create_params = Azure::ARM::Compute::Models::VirtualMachine.new.tap do |vm|
             vm.location = location
             vm.availability_set = availabilitySet if availability_set && availability_set_id
             vm.tags = tags if tags
-            vm.os_profile = Azure::ARM::Compute::Models::OSProfile.new.tap do |os_profile|
-              os_profile.computer_name = computerName if computerName
-              os_profile.admin_username = adminUsername
-              os_profile.admin_password = adminPassword if adminPassword
-              os_profile.linux_configuration = Azure::ARM::Compute::Models::LinuxConfiguration.new.tap do |linux|
-                linux.disable_password_authentication = linuxConfiguration[:disablePasswordAuthentication].nil? ? true : linuxConfiguration[:disablePasswordAuthentication]
-                if ssh = linuxConfiguration[:ssh]
-                  linux.ssh = Azure::ARM::Compute::Models::SshConfiguration.new.tap do |ssh_config|
-                    if publicKeys = ssh[:publicKeys]
-                      public_keys = []
-                      publicKeys.each do |publicKey|
-                        sshPublicKey = Azure::ARM::Compute::Models::SshPublicKey.new.tap do |pub_key|
-                          pub_key.path = publicKey[:path] || "/home/#{adminUsername}/.ssh/authorized_keys"
-                          if publicKey[:keyData]
-                            pub_key.key_data = publicKey[:keyData]
-                          else
-                            raise "public key keyData not provided"
+            unless os_disk_exist
+              vm.os_profile = Azure::ARM::Compute::Models::OSProfile.new.tap do |os_profile|
+                os_profile.computer_name = computerName if computerName
+                os_profile.admin_username = adminUsername
+                os_profile.admin_password = adminPassword if adminPassword
+                if linuxConfiguration
+                  os_profile.linux_configuration = Azure::ARM::Compute::Models::LinuxConfiguration.new.tap do |linux|
+                    linux.disable_password_authentication = linuxConfiguration[:disablePasswordAuthentication].nil? ? true : linuxConfiguration[:disablePasswordAuthentication]
+                    if ssh = linuxConfiguration[:ssh]
+                      linux.ssh = Azure::ARM::Compute::Models::SshConfiguration.new.tap do |ssh_config|
+                        if publicKeys = ssh[:publicKeys]
+                          public_keys = []
+                          publicKeys.each do |publicKey|
+                            sshPublicKey = Azure::ARM::Compute::Models::SshPublicKey.new.tap do |pub_key|
+                              pub_key.path = publicKey[:path] || "/home/#{adminUsername}/.ssh/authorized_keys"
+                              if publicKey[:keyData]
+                                pub_key.key_data = publicKey[:keyData]
+                              else
+                                raise 'public key keyData not provided'
+                              end
+                            end
+                            public_keys << sshPublicKey
                           end
+                          ssh_config.public_keys = public_keys
                         end
-                        public_keys << sshPublicKey
                       end
-                      ssh_config.public_keys = public_keys
                     end
                   end
                 end
-              end if linuxConfiguration
-            end unless os_disk_exist
+              end
+            end
 
             vm.storage_profile = Azure::ARM::Compute::Models::StorageProfile.new.tap do |store_profile|
-              store_profile.image_reference = Azure::ARM::Compute::Models::ImageReference.new.tap do |ref|
-                ref.publisher = bootstrap_options[:storageProfile][:imageReference][:publisher]
-                ref.offer = bootstrap_options[:storageProfile][:imageReference][:offer]
-                ref.sku = bootstrap_options[:storageProfile][:imageReference][:sku]
-                ref.version = bootstrap_options[:storageProfile][:imageReference][:version]
-              end unless os_disk_exist
+              unless os_disk_exist
+                store_profile.image_reference = Azure::ARM::Compute::Models::ImageReference.new.tap do |ref|
+                  ref.publisher = bootstrap_options[:storageProfile][:imageReference][:publisher]
+                  ref.offer = bootstrap_options[:storageProfile][:imageReference][:offer]
+                  ref.sku = bootstrap_options[:storageProfile][:imageReference][:sku]
+                  ref.version = bootstrap_options[:storageProfile][:imageReference][:version]
+                end
+              end
               store_profile.os_disk = os_disk
             end
 
@@ -254,32 +258,32 @@ class Chef
           vm = azure_vm_service.virtual_machines.create_or_update(resource_group_name, machine_spec.name, vm_create_params)
 
           machine_spec.reference = {
-            "driver_version" => Chef::Provisioning::AzureRM::VERSION,
-            "allocated_at" => Time.now.utc.to_s,
-            "host_node" => action_handler.host_node,
-            "location" => location,
-            "resource_group_name" => resource_group_name,
-            "adminUsername" => adminUsername
+            'driver_version' => Chef::Provisioning::AzureRM::VERSION,
+            'allocated_at' => Time.now.utc.to_s,
+            'host_node' => action_handler.host_node,
+            'location' => location,
+            'resource_group_name' => resource_group_name,
+            'adminUsername' => adminUsername
           }
           machine_spec.driver_url = driver_url
           machine_spec.reference['key_name'] = bootstrap_options[:key_name] if bootstrap_options[:key_name]
           machine_spec.reference['transport_address_location'] = machine_options[:transport_address_location] if machine_options[:transport_address_location]
           machine_spec.reference['vm_name'] = machine_spec.name
-          case vm.storage_profile.os_disk.os_type.downcase
-          when 'windows'
-            machine_spec.reference['is_windows'] = true
-          else
-            machine_spec.reference['is_windows'] = false
-          end
+          machine_spec.reference['is_windows'] = case vm.storage_profile.os_disk.os_type.downcase
+                                                 when 'windows'
+                                                   true
+                                                 else
+                                                   false
+                                                 end
           action_handler.report_progress "Created #{machine_spec.name} in #{location}..."
         end
 
         def connect_to_machine(name, chef_server = nil)
-          if name.is_a?(MachineSpec)
-            machine_spec = name
-          else
-            machine_spec = Chef::Provisioning::ChefMachineSpec.get(name, chef_server)
-          end
+          machine_spec = if name.is_a?(MachineSpec)
+                           name
+                         else
+                           Chef::Provisioning::ChefMachineSpec.get(name, chef_server)
+                         end
 
           machine_for(machine_spec, machine_spec.reference)
         end
@@ -299,7 +303,7 @@ class Chef
           when 'stopped'
             action_handler.report_progress "#{machine_spec.name} is stopped. Driver can't start it, please contact admin"
             raise "#{machine_spec.name} is stopped"
-            #TODO: start the VM
+            # TODO: start the VM
           when nil
             raise "Could not find power state of #{machine_spec.name}"
           else
@@ -311,10 +315,10 @@ class Chef
         end
 
         # (see Chef::Provisioning::Driver#destroy_machine)
-        def destroy_machine(action_handler, machine_spec, machine_options)
+        def destroy_machine(action_handler, machine_spec, _machine_options)
           vm = vm_for(machine_spec)
           vm_name = machine_spec.name
-          resource_group_name = machine_spec.reference["resource_group_name"]
+          resource_group_name = machine_spec.reference['resource_group_name']
           # Check if we need to proceed
           return if vm.nil? || vm_name.nil? || resource_group_name.nil?
           # Skip if we don't actually need to do anything
@@ -330,6 +334,131 @@ class Chef
           action_handler.report_progress "Destroyed VM #{machine_spec.name}"
         end
 
+        # ####
+        def allocate_load_balancer(action_handler, lb_spec, lb_options, machine_specs)
+          tags = lb_options[:tags]
+          resource_group = lb_options[:resource_group]
+          location = lb_options[:location]
+          virtual_network = lb_options[:virtual_network]
+          subnet_name = lb_options[:subnet_name]
+
+          subinfo = azure_net_service.subnets.get(lb_options.resource_group, lb_options.virtual_network, lb_options.subnet_name)
+
+          backend_pool = []
+
+          count = backend_pool.count
+          backend_pool[0] = Azure::ARM::Network::Models::BackendAddressPool.new
+          backend_pool[0].name = lb_spec.name
+
+
+          frontend_ipconf = Azure::ARM::Network::Models::FrontendIPConfiguration.new.tap do |feip|
+            lb_options[:frontendIPConfigurations].each do |fendip|
+              feip.name = fendip[:name]
+              feip.subnet = subinfo
+              feip.private_ipallocation_method = fendip[:private_ipallocation_method]
+            end
+          end
+
+          probe = Azure::ARM::Network::Models::Probe.new.tap do |prb|
+            lb_options[:probes].each do |prbes|
+              prb.name = prbes[:name]
+              prb.port = prbes[:port]
+              prb.protocol = prbes[:protocol]
+              if prbes[:protocol].to_s == "http"
+                prb.request_path = prbes[:request_path]
+              else
+                prb.request_path = nil
+              end
+              prb.interval_in_seconds = prbes[:interval_in_seconds]
+              prb.number_of_probes = prbes[:number_of_probes]
+            end
+          end
+
+          lb = Azure::ARM::Network::Models::LoadBalancer.new.tap do |lbinfo|
+            lbinfo.location = location
+            lbinfo.tags = tags
+            lbinfo.frontend_ipconfigurations = [frontend_ipconf]
+            lbinfo.backend_address_pools = backend_pool
+            lbinfo.probes = [probe]
+          end
+
+          lb_update(resource_group, lb_spec.name, lb) # inital build
+
+          mylb = azure_net_service.load_balancers.get(resource_group, lb_spec.name)
+
+          machine_specs.each do |ivm|
+            vmnic = azure_net_service.network_interfaces.get(resource_group, ivm.name)
+            mylb.backend_address_pools.each do |pool|
+              vmnic.ip_configurations.first.load_balancer_backend_address_pools = [pool] # mylb.backend_address_pools
+              azure_net_service.network_interfaces.create_or_update(resource_group, ivm.name, vmnic)
+            end
+          end
+
+          frontend_ipconf_sub = MsRestAzure::SubResource.new.tap do |subresource|
+            subresource.id = azure_net_service.load_balancers.get(resource_group, lb_spec.name).frontend_ipconfigurations.first.id
+          end
+
+          backend_ipconf_sub = MsRestAzure::SubResource.new.tap do |subresource|
+            subresource.id = mylb.backend_address_pools.first.id
+          end
+
+          probe_sub = MsRestAzure::SubResource.new.tap do |subresource|
+            subresource.id = azure_net_service.load_balancers.get(resource_group, lb_spec.name).probes.first.id
+          end
+
+          unless lb_options[:inboundNatRules].nil?
+            inboudnat = Azure::ARM::Network::Models::InboundNatRule.new.tap do |inat|
+              lb_options[:inboundNatRules].each do |ibnat|
+                inat.name = ibnat[:name]
+                inat.frontend_port = ibnat[:frontend_port]
+                inat.backend_port = ibnat[:backend_port]
+                inat.protocol = ibnat[:protocol]
+                inat.enable_floating_ip = ibnat[:enable_floating_ip]
+                inat.idle_timeout_in_minutes = ibnat[:idle_timeout_in_minutes]
+                inat.frontend_ipconfiguration = frontend_ipconf_sub
+              end
+            end
+          end
+
+          lbrules = Azure::ARM::Network::Models::LoadBalancingRule.new.tap do |lbrs|
+            lb_options[:loadBalancingRules].each do |lbr|
+              lbrs.name = lbr[:name]
+              lbrs.backend_address_pool = backend_ipconf_sub
+              lbrs.protocol = lbr[:protocol]
+              lbrs.backend_port = lbr[:backend_port]
+              lbrs.frontend_port = lbr[:frontend_port]
+              lbrs.idle_timeout_in_minutes = lbr[:idle_timeout_in_minutes]
+              lbrs.enable_floating_ip = lbr[:enable_floating_ip]
+              lbrs.load_distribution = lbr[:load_distribution]
+              lbrs.frontend_ipconfiguration = frontend_ipconf_sub
+              lbrs.backend_address_pool = backend_ipconf_sub
+              lbrs.probe = probe_sub
+            end
+          end
+
+          lb = Azure::ARM::Network::Models::LoadBalancer.new.tap do |lbinfo|
+            lbinfo.location = location
+            lbinfo.tags = tags
+            lbinfo.frontend_ipconfigurations = [frontend_ipconf]
+            lbinfo.backend_address_pools = backend_pool
+            unless lb_options[:inboundNatRules].nil?
+              lbinfo.inbound_nat_rules = [inboudnat]
+            end
+            lbinfo.probes = [probe]
+            lbinfo.load_balancing_rules = [lbrules]
+          end
+          lb_update(resource_group, lb_spec.name, lb) # update additions build
+        end
+
+        def lb_update(resource_group, name, lb)
+          azure_net_service.load_balancers.create_or_update(resource_group, name, lb)
+        end
+
+        def destroy_load_balancer(action_handler, lb_spec, lb_options)
+          raise "#{lb_spec.name} hasn't recived a resource group. Unable to destroy." unless lb_options.resource_group
+          azure_net_service.load_balancers.delete(lb_options.resource_group, lb_spec.name)
+        end
+
         private
 
         def machine_for(machine_spec, machine_options, vm = nil)
@@ -340,7 +469,7 @@ class Chef
           convergence_strategy = convergence_strategy_for(machine_spec, machine_options)
 
           if machine_spec.reference['is_windows']
-            raise "Sorry, No windows convergance support yet."
+            raise 'Sorry, No windows convergance support yet.'
           else
             Chef::Provisioning::Machine::UnixMachine.new(machine_spec, transport, convergence_strategy)
           end
@@ -361,7 +490,7 @@ class Chef
         end
 
         def default_ssh_username
-          "ubuntu"
+          'ubuntu'
         end
 
         def vm_for(machine_spec)
@@ -381,7 +510,7 @@ class Chef
 
         def transport_for(machine_spec, machine_options, vm)
           if machine_spec.reference['is_windows']
-            raise "Sorry, No windows convergance support yet."
+            raise 'Sorry, No windows convergance support yet.'
           else
             create_ssh_transport(machine_spec, machine_options, vm)
           end
@@ -391,12 +520,12 @@ class Chef
           ssh_options = ssh_options_for(machine_spec, machine_options, vm)
           username = machine_spec.reference['adminUsername'] || default_ssh_username
           options = {}
-          if machine_spec.reference[:sudo] || (!machine_spec.reference.has_key?(:sudo) && username != 'root')
+          if machine_spec.reference[:sudo] || (!machine_spec.reference.key?(:sudo) && username != 'root')
             options[:prefix] = 'sudo '
           end
-          #Enable pty by default
+          # Enable pty by default
           options[:ssh_pty_enable] = true
-          if machine_spec.reference.has_key?('ssh_gateway')
+          if machine_spec.reference.key?('ssh_gateway')
             options[:ssh_gateway] = machine_spec.reference['ssh_gateway']
           elsif machine_options[:ssh_gateway]
             options[:ssh_gateway] = machine_options[:ssh_gateway]
@@ -414,12 +543,12 @@ class Chef
 
         def ssh_options_for(machine_spec, machine_options, vm)
           result = {
-            :auth_methods => [ 'publickey' ],
-            :keys_only => true
+            auth_methods: ['publickey'],
+            keys_only: true
           }.merge(machine_options[:ssh_options] || {})
-          unless result.has_key?(:key_data)
+          unless result.key?(:key_data)
             result[:keys_only] = true
-            result[:key_data] = [ private_key_for(machine_spec, machine_options, vm) ]
+            result[:key_data] = [private_key_for(machine_spec, machine_options, vm)]
           end
           result
         end
@@ -437,7 +566,7 @@ class Chef
           request_url = azure_net_service.base_url
           options = {
             middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
-            query_params: {'api-version' => api_version,'$expand' => nil},
+            query_params: { 'api-version' => api_version, '$expand' => nil },
             headers: request_headers,
             base_url: request_url
           }
@@ -458,7 +587,7 @@ class Chef
           end
         end
 
-        def private_key_for(machine_spec, machine_options, vm)
+        def private_key_for(machine_spec, machine_options, _vm)
           if machine_spec.reference['key_name']
             key = get_private_key(machine_spec.reference['key_name'])
             unless key
@@ -470,7 +599,7 @@ class Chef
           elsif machine_options[:bootstrap_options] && machine_options[:bootstrap_options][:key_name]
             get_private_key(machine_options[:bootstrap_options][:key_name])
           else
-            # TODO make a way to suggest other keys to try ...
+            # TODO: make a way to suggest other keys to try ...
             raise "No key found to connect to #{machine_spec.name} (#{machine_spec.reference.inspect})!"
           end
         end
@@ -483,12 +612,12 @@ class Chef
           )
 
           # Defaults
-          if !machine_spec.reference
+          unless machine_spec.reference
             return Chef::Provisioning::ConvergenceStrategy::NoConverge.new(convergence_options, config)
           end
 
           if machine_spec.reference['is_windows']
-            raise "Sorry, No windows convergance support yet."
+            raise 'Sorry, No windows convergance support yet.'
           elsif machine_options[:cached_installer] == true
             Chef::Provisioning::ConvergenceStrategy::InstallCached.new(convergence_options, config)
           else
@@ -529,11 +658,11 @@ class Chef
               action_handler.report_progress "waiting for #{machine_spec.name} (#{driver_url}) to be connectable (transport up and running) ..."
               max_wait_time = Chef::Config.chef_provisioning[:machine_max_wait_time] || 120
               Retryable.retryable(
-                :tries => (max_wait_time/sleep_time).to_i,
-                :sleep => sleep_time,
-                :matching => /did not become connectable within/
-              ) do |retries, exception|
-                action_handler.report_progress "been waiting #{sleep_time*retries}/#{max_wait_time} -- sleeping #{sleep_time} seconds for #{machine_spec.name} (#{driver_url}) to become connectable ..."
+                tries: (max_wait_time / sleep_time).to_i,
+                sleep: sleep_time,
+                matching: /did not become connectable within/
+              ) do |retries, _exception|
+                action_handler.report_progress "been waiting #{sleep_time * retries}/#{max_wait_time} -- sleeping #{sleep_time} seconds for #{machine_spec.name} (#{driver_url}) to become connectable ..."
                 unless transport.available?
                   raise "VM #{machine_spec.name} (#{driver_url}) did not become connectable within #{max_wait_time} seconds"
                 end

data/lib/chef/provisioning/azurerm/version.rb

@@ -1,7 +1,7 @@
 class Chef
   module Provisioning
     module AzureRM
-      VERSION = '1.0.7'.freeze
+      VERSION = '1.0.8'.freeze
     end
   end
 end

data/lib/chef/resource/azure_load_balancer.rb

@@ -0,0 +1,18 @@
+require 'chef/provisioning/azurerm/azure_resource'
+
+class Chef
+  class Resource
+    class AzureLoadBalancer < Chef::Provisioning::AzureRM::AzureResource
+      resource_name :azure_load_balancer
+      actions :create, :destroy, :nothing
+      default_action :create
+      attribute :name, kind_of: String, name_attribute: true
+      attribute :resource_group, kind_of: String
+      attribute :location, kind_of: String, default: 'westus'
+      attribute :load_balancer_options, kind_of: Hash
+      attribute :virtual_network, kind_of: String
+      attribute :subnet_name, kind_of: String
+      attribute :virtual_machine, kind_of: Array
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cheese-chef-provisioning-azurerm
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors:
 - Stuart Preston
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-21 00:00:00.000000000 Z
+date: 2017-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
@@ -133,6 +133,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/chef/provider/azure_data_disk.rb
+- lib/chef/provider/azure_load_balancer.rb
 - lib/chef/provider/azure_network_interface.rb
 - lib/chef/provider/azure_public_ip_address.rb
 - lib/chef/provider/azure_resource_group.rb
@@ -148,6 +149,7 @@ files:
 - lib/chef/provisioning/azurerm/version.rb
 - lib/chef/provisioning/driver_init/azurerm.rb
 - lib/chef/resource/azure_data_disk.rb
+- lib/chef/resource/azure_load_balancer.rb
 - lib/chef/resource/azure_network_interface.rb
 - lib/chef/resource/azure_public_ip_address.rb
 - lib/chef/resource/azure_resource_group.rb
@@ -174,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Chef Provisioner for the Azure Resource Management (ARM) REST API.