fog-azure-rm 0.0.1 → 0.0.2

data/lib/fog/azurerm/requests/dns/delete_zone.rb

@@ -1,36 +1,33 @@
 module Fog
   module DNS
     class AzureRM
+      # Real class for DNS Request
       class Real
-
-        def delete_zone(zone_name, dns_resource_group)
-          Fog::Logger.debug "Deleting Zone #{zone_name} ..."
-          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{dns_resource_group}/providers/Microsoft.Network/dnsZones/#{zone_name}?api-version=2015-05-04-preview"
+        def delete_zone(resource_group, name)
+          Fog::Logger.debug "Deleting Zone #{name} ..."
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Network/dnsZones/#{name}?api-version=2015-05-04-preview"
           begin
             token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
             RestClient.delete(
-                resource_url,
-                accept: 'application/json',
-                content_type: 'application/json',
-                authorization: token)
-            Fog::Logger.debug "Zone #{zone_name} deleted successfully."
+              resource_url,
+              accept: 'application/json',
+              content_type: 'application/json',
+              authorization: token)
+            Fog::Logger.debug "Zone #{name} deleted successfully."
             true
-          rescue RestClient::Exception => e
-            body = JSON.parse(e.http_body)
-            if body.key?('error')
-              body = body['error']
-              msg = "Exception deleting zone: #{body['code']}, #{body['message']}"
-            else
-              msg = "Exception deleting zone: #{body['code']}, #{body['message']}"
-            end
+          rescue Exception => e
+            Fog::Logger.warning "Exception deleting zone #{name} from resource group #{resource_group}"
+            msg = "AzureDns::Zone - Exception is: #{e.message}"
             raise msg
           end
         end
       end
 
+      # Mock class for DNS Request
       class Mock
-        def delete_zone(zone_name, dns_resource_group)
-
+        def delete_zone(_resource_group, _name)
+          Fog::Logger.debug "Zone #{_name} deleted successfully."
+          return true
         end
       end
     end

data/lib/fog/azurerm/requests/dns/get_records_from_record_set.rb

@@ -1,44 +1,40 @@
 module Fog
   module DNS
     class AzureRM
+      # Real class for DNS Request
       class Real
-        def get_records_from_record_set(record_set_name, dns_resource_group, zone_name, record_type)
-          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{dns_resource_group}/providers/Microsoft.Network/dnsZones/#{zone_name}/#{record_type}/#{record_set_name}?api-version=2015-05-04-preview"
-          Fog::Logger.debug "Getting all records from RecordSet #{record_set_name} of type '#{record_type}' in zone #{zone_name}"
+        def get_records_from_record_set(resource_group, name, zone_name, record_type)
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Network/dnsZones/#{zone_name}/#{record_type}/#{name}?api-version=2015-05-04-preview"
+          Fog::Logger.debug "Getting all records from RecordSet #{name} of type '#{record_type}' in zone #{zone_name}"
 
-          existing_records = Array.new
+          existing_records = []
           begin
             token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
             dns_response = RestClient.get(
-                resource_url,
-                accept: 'application/json',
-                content_type: 'application/json',
-                authorization: token
+              resource_url,
+              accept: 'application/json',
+              content_type: 'application/json',
+              authorization: token
             )
           rescue Exception => e
-            if e.http_code == 404
-              Fog::Logger.warning 'AzureDns::RecordSet - 404 code, record set does not exist.  returning empty array'
-              return existing_records
-            else
-              Fog::Logger.warning "Exception trying to get existing #{record_type} records for the record set: #{record_set_name}"
-              msg = "AzureDns::RecordSet - Exception is: #{e.message}"
-              raise msg
-            end
+            Fog::Logger.warning "Exception trying to get existing #{record_type} records for the record set: #{name}"
+            msg = "AzureDns::RecordSet - Exception is: #{e.message}"
+            raise msg
           end
 
           begin
             dns_hash = JSON.parse(dns_response)
             case record_type
-              when 'A'
-                dns_hash['properties']['ARecords'].each do |record|
-                  Fog::Logger.debug "AzureDns:RecordSet - A record is: #{record}"
-                  existing_records.push(record['ipv4Address'])
-                end
-              when 'CNAME'
-                Fog::Logger.debug "AzureDns:RecordSet - CNAME record is: #{dns_hash['properties']['CNAMERecord']['cname']}"
-                existing_records.push(dns_hash['properties']['CNAMERecord']['cname'])
+            when 'A'
+              dns_hash['properties']['ARecords'].each do |record|
+                Fog::Logger.debug "AzureDns:RecordSet - A record is: #{record}"
+                existing_records.push(record['ipv4Address'])
+              end
+            when 'CNAME'
+              Fog::Logger.debug "AzureDns:RecordSet - CNAME record is: #{dns_hash['properties']['CNAMERecord']['cname']}"
+              existing_records.push(dns_hash['properties']['CNAMERecord']['cname'])
             end
-            return existing_records
+            existing_records
           rescue Exception => e
             Fog::Logger.warning "Exception trying to parse response: #{dns_response}"
             msg = "AzureDns::RecordSet - Exception is: #{e.message}"
@@ -47,11 +43,16 @@ module Fog
         end
       end
 
+      # Mock class for DNS Request
       class Mock
-        def get_records_from_record_set(record_set_name, dns_resource_group, zone_name, record_type)
-
+        def get_records_from_record_set(_resource_group, _name, _zone_name, _record_type)
+          [
+            "1.2.3.4",
+            "1.2.3.5",
+            "1.2.3.6"
+          ]
         end
       end
     end
   end
-end
+end

data/lib/fog/azurerm/requests/dns/list_record_sets.rb

@@ -1,9 +1,10 @@
 module Fog
   module DNS
     class AzureRM
+      # Real class for DNS Request
       class Real
-        def list_record_sets(dns_resource_group, zone_name)
-          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{dns_resource_group}/providers/Microsoft.Network/dnsZones/#{zone_name}/recordsets?api-version=2015-05-04-preview"
+        def list_record_sets(resource_group, zone_name)
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Network/dnsZones/#{zone_name}/recordsets?api-version=2015-05-04-preview"
           begin
             token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
             dns_response = RestClient.get(
@@ -11,34 +12,59 @@ module Fog
               accept: 'application/json',
               content_type: 'application/json',
               authorization: token)
-            response_hash = JSON.parse(dns_response)
-            response_hash['value']
-          rescue RestClient::Exception => e
-            body = JSON.parse(e.http_body)
-            if body.key?('error')
-              body = body['error']
-              msg = "Exception fetching record_sets: #{body['code']}, #{body['message']}"
-            else
-              msg = "Exception fetching record_sets: #{body['code']}, #{body['message']}"
-            end
+            parsed_zone = JSON.parse(dns_response)
+            parsed_zone['value']
+          rescue Exception => e
+            Fog::Logger.warning "Exception listing recordsets in zone #{zone_name} in resource group #{resource_group}"
+            msg = "AzureDns::RecordSet - Exception is: #{e.message}"
             raise msg
           end
         end
       end
 
+      # Mock class for DNS Request
       class Mock
-        def list_record_sets(dns_resource_group, zone_name)
-          rset = {
-            :name => 'fogtestrecordset',
-            :resource_group => 'fog-test-resource-group',
-            :zone_name => 'fogtestzone.com',
-            :records => ['1.2.3.4', '1.2.3.3'],
-            :type => 'A',
-            :ttl => 60
-          }
-          [rset]
+        def list_record_sets(_resource_group, _zone_name)
+          [
+            {
+              "id"=>"/subscriptions/########-####-####-####-############/resourceGroups/#{_resource_group}/providers/Microsoft.Network/dnszones/#{_zone_name}/A/test_record",
+              "name"=>"test_record",
+              "type"=>"Microsoft.Network/dnszones/A",
+              "etag"=>"7f159cb1-653d-4920-bc03-153c700412a2",
+              "location"=>"global",
+              "properties"=>
+                {
+                  "metadata"=>nil,
+                  "fqdn"=>"test_record.#{_zone_name}.",
+                  "TTL"=>60,
+                  "ARecords"=>
+                    [
+                      {
+                        "ipv4Address"=>"1.2.3.4"
+                      }
+                    ]
+                }
+            },
+            {
+              "id"=>"/subscriptions/########-####-####-####-############/resourceGroups/#{_resource_group}/providers/Microsoft.Network/dnszones/#{_zone_name}/CNAME/test_record1",
+              "name"=>"test_record1",
+              "type"=>"Microsoft.Network/dnszones/CNAME",
+              "etag"=>"cc5ceb6e-16ad-4a5f-bbd7-9bc31c12d0cf",
+              "location"=>"global",
+              "properties"=>
+                {
+                  "metadata"=>nil,
+                  "fqdn"=>"test_record1.#{_zone_name}.",
+                  "TTL"=>60,
+                  "CNAMERecord"=>
+                    {
+                      "cname"=>"1.2.3.4"
+                    }
+                }
+            }
+          ]
         end
       end
     end
   end
-end
+end

data/lib/fog/azurerm/requests/dns/list_zones.rb

@@ -1,12 +1,12 @@
 module Fog
   module DNS
     class AzureRM
+      # Real class for DNS Request
       class Real
         def list_zones
           zone_hash_array = []
           @resources.resource_groups.each do |rg|
             list_zones_by_rg(rg.name).each do |zone_hash|
-              zone_hash['resource_group'] = rg.name              
               zone_hash_array << zone_hash
             end
           end
@@ -15,38 +15,72 @@ module Fog
 
         private
 
-        def list_zones_by_rg(dns_resource_group)
-          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{dns_resource_group}/providers/Microsoft.Network/dnsZones?api-version=2015-05-04-preview"
+        def list_zones_by_rg(resource_group)
+          resource_url = "#{AZURE_RESOURCE}/subscriptions/#{@subscription_id}/resourceGroups/#{resource_group}/providers/Microsoft.Network/dnsZones?api-version=2015-05-04-preview"
           begin
             token = Fog::Credentials::AzureRM.get_token(@tenant_id, @client_id, @client_secret)
             dns_response = RestClient.get(
-                resource_url,
-                accept: 'application/json',
-                content_type: 'application/json',
-                authorization: token)
-            response_hash = JSON.parse(dns_response)
-            response_hash['value']
-          rescue RestClient::Exception => e
-            body = JSON.parse(e.http_body)
-            if body.key?('error')
-              body = body['error']
-              msg = "Exception fetching zones: #{body['code']}, #{body['message']}"
-            else
-              msg = "Exception fetching zones: #{body['code']}, #{body['message']}"
-            end
+              resource_url,
+              accept: 'application/json',
+              content_type: 'application/json',
+              authorization: token)
+            parsed_zone = JSON.parse(dns_response)
+            parsed_zone['value']
+          rescue Exception => e
+            Fog::Logger.warning "Exception listing zones in resource group #{resource_group}"
+            msg = "AzureDns::RecordSet - Exception is: #{e.message}"
             raise msg
           end
         end
       end
 
+      # Mock class for DNS Request
       class Mock
         def list_zones
-          zone = {
-            id: '/subscriptions/########-####-####-####-############/resourceGroups/fog-test-resource-group/Microsoft.Network/dnszones/fogtestzone.com',
-            name: 'fogtestzone.com',
-            resource_group: 'fog-test-resource-group'
-          }
-          [zone]
+          [
+            {
+              "id"=>"/subscriptions/########-####-####-####-############/resourceGroups/fog_test_rg/providers/Microsoft.Network/dnszones/testfog1.com",
+              "name"=>"testfog1.com",
+              "type"=>"Microsoft.Network/dnszones",
+              "etag"=> "00000002-0000-0000-76c2-f7ad90b5d101",
+              "location"=>"global",
+              "tags"=>{},
+              "properties"=>
+                {
+                  "maxNumberOfRecordSets"=>5000,
+                  "nameServers"=>
+                    [
+                      "ns1-05.azure-dns.com.",
+                      "ns2-05.azure-dns.net.",
+                      "ns3-05.azure-dns.org.",
+                      "ns4-05.azure-dns.info."
+                    ],
+                  "numberOfRecordSets"=>2,
+                  "parentResourceGroupName"=>"fog_test_rg"
+                }
+            },
+            {
+              "id"=>"/subscriptions/########-####-####-####-############/resourceGroups/fog_test_rg/providers/Microsoft.Network/dnszones/testfog.com",
+              "name"=>"testfog.com",
+              "type"=>"Microsoft.Network/dnszones",
+              "etag"=>"00000002-0000-0000-4215-c21c8fb5d101",
+              "location"=>"global",
+              "tags"=>{},
+              "properties"=>
+                {
+                  "maxNumberOfRecordSets"=>5000,
+                  "nameServers"=>
+                    [
+                      "ns1-02.azure-dns.com.",
+                      "ns2-02.azure-dns.net.",
+                      "ns3-02.azure-dns.org.",
+                      "ns4-02.azure-dns.info."
+                    ],
+                  "numberOfRecordSets"=>2,
+                  "parentResourceGroupName"=>"fog_test_rg"
+                }
+              }
+            ]
         end
       end
     end

data/lib/fog/azurerm/requests/network/check_for_public_ip.rb

@@ -18,7 +18,9 @@ module Fog
 
       # Mock class for Network Request
       class Mock
-        def check_for_public_ip(_resource_group, _name)
+        def check_for_public_ip(resource_group, name)
+          Fog::Logger.debug "Public IP #{name} from Resource group #{resource_group} is available."
+          return true
         end
       end
     end

data/lib/fog/azurerm/requests/network/check_for_virtual_network.rb

@@ -3,7 +3,7 @@ module Fog
     class AzureRM
       # Mock class for Network Request
       class Real
-        def check_for_virtual_network(name, resource_group)
+        def check_for_virtual_network(resource_group, name)
           begin
             promise = @network_client.virtual_networks.get(resource_group, name)
             promise.value!
@@ -18,7 +18,9 @@ module Fog
 
       # Mock class for Network Request
       class Mock
-        def check_for_virtual_network(_name, _resource_group)
+        def check_for_virtual_network(resource_group, name)
+          Fog::Logger.debug "Virtual Network #{name} from Resource group #{resource_group} is available."
+          return true
         end
       end
     end

data/lib/fog/azurerm/requests/network/create_load_balancer.rb

@@ -0,0 +1,208 @@
+module Fog
+  module Network
+    class AzureRM
+      # Real class for Network Request
+      class Real
+        def create_load_balancer(name, location, resource_group, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+          Fog::Logger.debug "Creating Load-Balancer: #{name}..."
+          load_balancer = define_load_balancer(name, location, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+          begin
+            promise = @network_client.load_balancers.create_or_update(resource_group, name, load_balancer)
+            result = promise.value!
+            Fog::Logger.debug "Load-Balancer #{name} created successfully."
+            Azure::ARM::Network::Models::LoadBalancer.serialize_object(result.body)
+          rescue MsRestAzure::AzureOperationError => e
+            msg = "Exception creating Load-Balancer #{name} in Resource Group: #{resource_group}. #{e.body['error']['message']}"
+            raise msg
+          end
+        end
+
+        private
+
+        def define_load_balancer(name, location, frontend_ip_configurations, backend_address_pool_names, load_balancing_rules, probes, inbound_nat_rules, inbound_nat_pools)
+          lb_props = Azure::ARM::Network::Models::LoadBalancerPropertiesFormat.new
+
+          if frontend_ip_configurations
+            frontend_ip_configuration_arr = define_frontend_ip_configurations(frontend_ip_configurations)
+            lb_props.frontend_ipconfigurations = []
+            lb_props.frontend_ipconfigurations = frontend_ip_configuration_arr
+          end
+
+          if backend_address_pool_names
+            lb_props.backend_address_pools = []
+            backend_address_pool_names.each do |bap|
+              backend_pool = Azure::ARM::Network::Models::BackendAddressPool.new
+              backend_pool.name = bap
+              lb_props.backend_address_pools.push(backend_pool)
+            end
+          end
+
+          if load_balancing_rules
+            lb_props.load_balancing_rules = []
+            load_balancing_rule_arr = define_load_balancing_rule(load_balancing_rules)
+            lb_props.load_balancing_rules = load_balancing_rule_arr
+          end
+
+          if probes
+            lb_props.probes = []
+            probe_arr = define_probe(probes)
+            lb_props.probes = probe_arr
+          end
+
+          if inbound_nat_rules
+            lb_props.inbound_nat_rules = []
+            inbound_nat_rule_arr = define_inbound_nat_rule(inbound_nat_rules)
+            lb_props.inbound_nat_rules = inbound_nat_rule_arr
+          end
+
+          if inbound_nat_pools
+            lb_props.inbound_nat_pools = []
+            inbound_nat_pool_arr = define_inbound_nat_pool(inbound_nat_pools)
+            lb_props.inbound_nat_pools = inbound_nat_pool_arr
+          end
+
+          load_balancer = Azure::ARM::Network::Models::LoadBalancer.new
+          load_balancer.name = name
+          load_balancer.location = location
+          load_balancer.properties = lb_props
+
+          load_balancer
+        end
+
+        def define_inbound_nat_pool(inbound_nat_pools)
+          inbound_nat_pool_arr = []
+          inbound_nat_pools.each do |inp|
+            inbound_nat_pool = Azure::ARM::Network::Models::InboundNatPool.new
+            inbound_nat_pool_prop = Azure::ARM::Network::Models::InboundNatPoolPropertiesFormat.new
+
+            unless inp[:frontend_ip_configuration_id].nil?
+              frontend_ipconfigurations = Azure::ARM::Network::Models::FrontendIPConfiguration.new
+              frontend_ipconfigurations.id = inp[:frontend_ip_configuration_id]
+              inbound_nat_pool_prop.frontend_ipconfiguration = frontend_ipconfigurations
+            end
+
+            inbound_nat_pool_prop.protocol = inp[:protocol]
+            inbound_nat_pool_prop.frontend_port_range_start = inp[:frontend_port_range_start]
+            inbound_nat_pool_prop.frontend_port_range_end = inp[:frontend_port_range_end]
+            inbound_nat_pool_prop.backend_port = inp[:backend_port]
+
+            inbound_nat_pool.name = inp[:name]
+            inbound_nat_pool.properties = inbound_nat_pool_prop
+            inbound_nat_pool_arr.push(inbound_nat_pool)
+          end
+          inbound_nat_pool_arr
+        end
+
+        def define_inbound_nat_rule(inbound_nat_rules)
+          inbound_nat_rule_arr = []
+          inbound_nat_rules.each do |inr|
+            inbound_nat_rule = Azure::ARM::Network::Models::InboundNatRule.new
+            inbound_nat_rule_prop = Azure::ARM::Network::Models::InboundNatRulePropertiesFormat.new
+
+            unless inr[:frontend_ip_configuration_id].nil?
+              frontend_ipconfigurations = Azure::ARM::Network::Models::FrontendIPConfiguration.new
+              frontend_ipconfigurations.id = inr[:frontend_ip_configuration_id]
+              inbound_nat_rule_prop.frontend_ipconfiguration = frontend_ipconfigurations
+            end
+            inbound_nat_rule_prop.protocol = inr[:protocol]
+            inbound_nat_rule_prop.frontend_port = inr[:frontend_port]
+            inbound_nat_rule_prop.backend_port = inr[:backend_port]
+
+            inbound_nat_rule.name = inr[:name]
+            inbound_nat_rule.properties = inbound_nat_rule_prop
+            inbound_nat_rule_arr.push(inbound_nat_rule)
+          end
+          inbound_nat_rule_arr
+        end
+
+        def define_probe(probes)
+          probe_arr = []
+          probes.each do |prb|
+            probe = Azure::ARM::Network::Models::Probe.new
+            probe_prop = Azure::ARM::Network::Models::ProbePropertiesFormat.new
+
+            probe_prop.protocol = prb[:protocol]
+            probe_prop.port = prb[:port]
+            probe_prop.interval_in_seconds = prb[:interval_in_seconds]
+            probe_prop.number_of_probes = prb[:number_of_probes]
+            probe_prop.request_path = prb[:request_path]
+
+            probe.name = prb[:name]
+            probe.properties = probe_prop
+            probe_arr.push(probe)
+          end
+          probe_arr
+        end
+
+        def define_load_balancing_rule(load_balancing_rules)
+          load_balancing_rule_arr = []
+          load_balancing_rules.each do |lbr|
+            load_balancing_rule = Azure::ARM::Network::Models::LoadBalancingRule.new
+            load_balancing_rule_prop = Azure::ARM::Network::Models::LoadBalancingRulePropertiesFormat.new
+
+            load_balancing_rule_prop.protocol = lbr[:protocol]
+            load_balancing_rule_prop.load_distribution = lbr[:load_distribution]
+            load_balancing_rule_prop.idle_timeout_in_minutes = lbr[:idle_timeout_in_minutes]
+            load_balancing_rule_prop.frontend_port = lbr[:frontend_port]
+            load_balancing_rule_prop.backend_port = lbr[:backend_port]
+            load_balancing_rule_prop.enable_floating_ip = lbr[:enable_floating_ip]
+
+            unless lbr[:frontend_ip_configuration_id].nil?
+              frontend_ipconfigurations = Azure::ARM::Network::Models::FrontendIPConfiguration.new
+              frontend_ipconfigurations.id = lbr[:frontend_ip_configuration_id]
+              load_balancing_rule_prop.frontend_ipconfiguration = frontend_ipconfigurations
+            end
+
+            unless lbr[:backend_address_pool_id].nil?
+              backend_address_pool = Azure::ARM::Network::Models::BackendAddressPool.new
+              backend_address_pool.id = lbr[:backend_address_pool_id]
+              load_balancing_rule_prop.backend_address_pool = backend_address_pool
+            end
+
+            unless lbr[:probe_id].nil?
+              probe = Azure::ARM::Network::Models::Probe.new
+              probe.id = lbr[:probe_id]
+              load_balancing_rule_prop.probe = probe
+            end
+
+            load_balancing_rule.name = lbr[:name]
+            load_balancing_rule.properties = load_balancing_rule_prop
+            load_balancing_rule_arr.push(load_balancing_rule)
+          end
+          load_balancing_rule_arr
+        end
+
+        def define_frontend_ip_configurations(frontend_ip_configurations)
+          frontend_ip_configuration_arr = []
+          frontend_ip_configurations.each do |fic|
+            frontend_ip_configuration = Azure::ARM::Network::Models::FrontendIPConfiguration.new
+            frontend_ip_configuration_prop = Azure::ARM::Network::Models::FrontendIPConfigurationPropertiesFormat.new
+            frontend_ip_configuration_prop.private_ipaddress = fic[:private_ipaddress]
+            frontend_ip_configuration_prop.private_ipallocation_method = fic[:private_ipallocation_method]
+            unless fic[:subnet_id].nil?
+              snet = Azure::ARM::Network::Models::Subnet.new
+              snet.id = fic[:subnet_id]
+              frontend_ip_configuration_prop.subnet = snet
+            end
+            unless fic[:public_ipaddress_id].nil?
+              pip = Azure::ARM::Network::Models::PublicIPAddress.new
+              pip.id = fic[:public_ipaddress_id]
+              frontend_ip_configuration_prop.public_ipaddress = pip
+            end
+
+            frontend_ip_configuration.name = fic[:name]
+            frontend_ip_configuration.properties = frontend_ip_configuration_prop
+            frontend_ip_configuration_arr.push(frontend_ip_configuration)
+          end
+          frontend_ip_configuration_arr
+        end
+      end
+
+      # Mock class for Network Request
+      class Mock
+        def create_load_balancer(_name, _location, _resource_group, _frontend_ip_configuration_name, _subnet_id, _private_ip_address, _private_ip_allocation_method, _public_ip_address_id, _backend_address_pool_names, _load_balancing_rules, _probes, _inbound_nat_rules, _inbound_nat_pools)
+        end
+      end
+    end
+  end
+end