Network¶ ↑
This document explains how to get started using Azure Network Service with Fog
. With this gem you can create/update/list/delete virtual networks, subnets, public IPs and network interfaces.
Usage¶ ↑
First of all, you need to require the Fog
library by executing:
require 'fog/azurerm'
Create Connection¶ ↑
Next, create a connection to the Network Service:
azure_network_service = Fog::Network::AzureRM.new( tenant_id: '<Tenantid>', # Tenant id of Azure Active Directory Application client_id: '<Clientid>', # Client id of Azure Active Directory Application client_secret: '<ClientSecret>', # Client Secret of Azure Active Directory Application subscription_id: '<Subscriptionid>', # Subscription id of an Azure Account :environment => '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>' # Azure cloud environment. Default is AzureCloud. )
Check Virtual Network Existence¶ ↑
azure_network_service.virtual_networks.check_virtual_network_exists(<Resource Group name>, <Virtual Network Name>)
Create Virtual Network¶ ↑
Create a new virtual network
Optional parameters for Virtual Network: subnets, dns_servers & address_prefixes Optional parameters for Subnet: network_security_group_id, route_table_id & address_prefix
vnet = azure_network_service.virtual_networks.create( name: '<Virtual Network Name>', location: 'westus', resource_group: '<Resource Group Name>', subnets: [{ name: '<Subnet Name>', address_prefix: '10.1.0.0/24', network_security_group_id: '/subscriptions/<Subscription Id>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/networkSecurityGroups/<Network Security Group Name>', route_table_id: '/subscriptions/<Subscription Id>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/routeTables/<Route Table Name>' }], dns_servers: ['10.1.0.0','10.2.0.0'], address_prefixes: ['10.1.0.0/16','10.2.0.0/16'] )
List Virtual Networks in Resource Group¶ ↑
List all virtual networks in a resource group
vnets = azure_network_service.virtual_networks(resource_group: '<Resource Group Name>') vnets.each do |vnet| puts "#{vnet.name}" puts "#{vnet.location}" end
List Virtual Networks in Subscription¶ ↑
List all virtual networks in a subscription
vnets = azure_network_service.virtual_networks vnets.each do |vnet| puts "#{vnet.name}" puts "#{vnet.location}" end
Retrieve a single Virtual Network¶ ↑
Get a single record of virtual network
vnet = azure_network_service.virtual_networks.get('<Resource Group Name>', '<Virtual Network name>') puts "#{vnet.name}"
Add/Remove DNS Servers to/from Virtual Network¶ ↑
Add/Remove DNS Servers to/from Virtual Network
vnet.add_dns_servers(['10.3.0.0','10.4.0.0']) vnet.remove_dns_servers(['10.3.0.0','10.4.0.0'])
Add/Remove Address Prefixes to/from Virtual Network¶ ↑
Add/Remove Address Prefixes to/from Virtual Network
vnet.add_address_prefixes(['10.2.0.0/16', '10.3.0.0/16']) vnet.remove_address_prefixes(['10.2.0.0/16'])
Add/Remove Subnets to/from Virtual Network¶ ↑
Add/Remove Subnets to/from Virtual Network
vnet.add_subnets([{ name: 'test-subnet', address_prefix: '10.3.0.0/24' }]) vnet.remove_subnets(['test-subnet'])
Update Virtual Network¶ ↑
Update Virtual Network
vnet.update({ subnets:[{ name: 'fog-subnet', address_prefix: '10.3.0.0/16' }], dns_servers: ['10.3.0.0','10.4.0.0'] })
Destroy a single virtual network¶ ↑
Get virtual network object from the get method and then destroy that virtual network.
vnet.destroy
Check Subnet Existence¶ ↑
azure_network_service.subnets.check_subnet_exists(<Resource Group name>, <Virtual Network Name>, <Subnet Name>)
Create Subnet¶ ↑
Create a new Subnet
Optional parameters: network_security_group_id, route_table_id & address_prefix
subnet = azure_network_service.subnets.create( name: '<Subnet Name>', resource_group: '<Resource Group Name>', virtual_network_name: '<Virtual Network Name>', address_prefix: '10.0.0.0/24', network_security_group_id: '/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkSecurityGroups/<Network Security Group Name>', route_table_id: '/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/routeTables/<Route Table Name>' )
List Subnets¶ ↑
List subnets in a resource group and a virtual network
subnets = azure_network_service.subnets(resource_group: '<Resource Group name>', virtual_network_name: '<Virtual Network name>') subnets.each do |subnet| puts "#{subnet.name}" end
Retrieve a single Subnet¶ ↑
Get a single record of Subnet
subnet = azure_network_service .subnets .get('<Resource Group name>', '<Virtual Network name>', '<Subnet name>') puts "#{subnet.name}"
Attach Network Security Group to Subnet¶ ↑
Attach Network Security Group to Subnet
subnet = azure_network_service.attach_network_security_group('/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/networkSecurityGroups/<Network Security Group Name>') puts "#{subnet.network_security_group_id}"
Detach Network Security Group from Subnet¶ ↑
Detach Network Security Group from Subnet
subnet = azure_network_service.detach_network_security_group puts "#{subnet.network_security_group_id}"
Attach Route Table to Subnet¶ ↑
Attach Route Table to Subnet
subnet = azure_network_service.attach_route_table('/subscriptions/<Subscription Id>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/routeTables/<Route Table Name>') puts "#{subnet.route_table_id}"
Detach Route Table from Subnet¶ ↑
Detach Route Table from Subnet
subnet = azure_network_service.detach_route_table puts "#{subnet.route_table_id}"
List Number of Available IP Addresses in Subnet¶ ↑
The parameter is a boolean which checks if the Virtual Network the Subnet belongs to is attached to an Express Route Circuit or not
puts "#{subnet.get_available_ipaddresses_count(false)}"
Destroy a single Subnet¶ ↑
Get a subnet object from the get method and then destroy that subnet.
subnet.destroy
Check Network Interface Card Existence¶ ↑
azure_network_service.network_interfaces.check_network_interface_exists(<Resource Group name>, <Network Interface name>)
Create Network Interface Card¶ ↑
Create a new network interface. Skip public_ip_address_id parameter to create network interface without PublicIP. The parameter, private_ip_allocation_method can be Dynamic or Static.
nic = azure_network_service.network_interfaces.create( name: '<Network Interface name>', resource_group: '<Resource Group name>', location: 'eastus', subnet_id: '/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/virtualNetworks/<Virtual Network name>/subnets/<Subnet name>', public_ip_address_id: '/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/publicIPAddresses/<Public IP name>', ip_configuration_name: '<Ip Configuration Name>', private_ip_allocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic )
List Network Interface Cards¶ ↑
List network interfaces in a resource group
nics = azure_network_service.network_interfaces(resource_group: '<Resource Group name>') nics.each do |nic| puts "#{nic.name}" end
Retrieve a single Network Interface Card¶ ↑
Get a single record of Network Interface
nic = azure_network_service .network_interfaces .get('<Resource Group name>', '<Network Interface name>') puts "#{nic.name}"
Update Network Interface Card¶ ↑
You can update network interface by passing only updated attributes, in the form of hash. For example,
nic.update(private_ip_allocation_method: 'Static', private_ip_address: '10.0.0.0')
Attach/Detach resources to Network Interface Card¶ ↑
Attach Subnet, Public-IP or Network-Security-Group as following
subnet_id = "<NEW-SUBNET-ID>" nic.attach_subnet(subnet_id) public_ip_id = "<NEW-PUBLIC_IP-ID>" nic.attach_public_ip(public_ip_id) nsg_id = "<NEW-NSG-ID>" nic.attach_network_security_group(nsg_id)
Detach Public-IP or Network-Security-Group as following
nic.detach_public_ip nic.detach_network_security_group
Note: You can't detach subnet from Network Interface.
Destroy a single Network Interface Card¶ ↑
Get a network interface object from the get method and then destroy that network interface.
nic.destroy
Check Public IP Existence¶ ↑
azure_network_service.public_ips.check_public_ip_exists(<Resource Group name>, <Public IP name>>)
Create Public IP¶ ↑
Create a new public IP. The parameter, type can be Dynamic or Static.
pubip = azure_network_service.public_ips.create( name: '<Public IP name>', resource_group: '<Resource Group name>', location: 'westus', public_ip_allocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Static )
Check for Public IP¶ ↑
Checks if the Public IP already exists or not.
azure_network_service.public_ips.check_if_exists('<Public IP name>', '<Resource Group name>')
List Public IPs¶ ↑
List network interfaces in a resource group
pubips = azure_network_service.public_ips(resource_group: '<Resource Group name>') pubips.each do |pubip| puts "#{pubip.name}" end
Retrieve a single Public Ip¶ ↑
Get a single record of Public Ip
pubip = azure_network_service .public_ips .get('<Resource Group name>', '<Public IP name>') puts "#{pubip.name}"
Update Public Ip¶ ↑
Get a Public IP object from the get method and then update that public IP. You can update the Public IP by passing the modifiable attributes in the form of a hash.
pubip.update( public_ip_allocation_method: '<IP Allocation Method>', idle_timeout_in_minutes: '<Idle Timeout In Minutes>', domain_name_label: '<Domain Name Label>' )
Destroy a single Public Ip¶ ↑
Get a Public IP object from the get method and then destroy that public IP.
pubip.destroy
Check Network Security Group Existence¶ ↑
azure_network_service.network_security_groups.check_net_sec_group_exists(<Resource Group name>, <Network Security Group name>)
Create Network Security Group¶ ↑
Network security group requires a resource group to create.
azure_network_service.network_security_groups.create( name: '<Network Security Group name>', resource_group: '<Resource Group name>', location: 'eastus', security_rules: [{ name: '<Security Rule name>', protocol: Fog::ARM::Network::Models::SecurityRuleProtocol::Tcp, source_port_range: '22', destination_port_range: '22', source_address_prefix: '0.0.0.0/0', destination_address_prefix: '0.0.0.0/0', access: Fog::ARM::Network::Models::SecurityRuleAccess::Allow, priority: '100', direction: Fog::ARM::Network::Models::SecurityRuleDirection::Inbound }] )
List Network Security Groups¶ ↑
List all the network security groups in a resource group
network_security_groups = azure_network_service.network_security_groups(resource_group: '<Resource Group name>') network_security_groups.each do |nsg| puts "#{nsg.name}" end
Retrieve a single Network Security Group¶ ↑
Get a single record of Network Security Group
nsg = azure_network_service .network_security_groups .get('<Resource Group Name>','<Network Security Group name>') puts "#{nsg.name}"
Update Security Rules¶ ↑
You can update security rules by passing the modified attributes in the form of hash.
nsg.update_security_rules( security_rules: [ { name: '<Security Rule name>', protocol: Fog::ARM::Network::Models::SecurityRuleProtocol::Tcp, source_port_range: '*', destination_port_range: '*', source_address_prefix: '0.0.0.0/0', destination_address_prefix: '0.0.0.0/0', access: Fog::ARM::Network::Models::SecurityRuleAccess::Allow, priority: '100', direction: Fog::ARM::Network::Models::SecurityRuleDirection::Inbound } ] )
Note: You can't modify Name of a security rule.
Add and Remove Security Rules in a Network Security Group¶ ↑
Add array of security rules in the form of hash.
nsg.add_security_rules( [ { name: '<Security Rule name>', protocol: Fog::ARM::Network::Models::SecurityRuleProtocol::Tcp, source_port_range: '3389', destination_port_range: '3389', source_address_prefix: '0.0.0.0/0', destination_address_prefix: '0.0.0.0/0', access: Fog::ARM::Network::Models::SecurityRuleAccess::Allow, priority: '102', direction: Fog::ARM::Network::Models::SecurityRuleDirection::Inbound } ] )
Delete security rule by providing its name.
nsg.remove_security_rule('<Security Rule name>')
Destroy a Network Security Group¶ ↑
Get a network security group object from the get method and then destroy that network security group.
nsg.destroy
Check Network Security Rule Existence¶ ↑
azure_network_service.network_security_rules.check_net_sec_rule_exists(<Resource Group name>, <Network Security Group name>, <Security Rule name>)
Create Network Security Rule¶ ↑
Network security rule requires a resource group and network security group to create.
azure_network_service.network_security_rules.create( name: '<Security Rule name>', resource_group: '<Resource Group name>', protocol: Fog::ARM::Network::Models::SecurityRuleProtocol::Tcp, network_security_group_name: '<Network Security Group name>', source_port_range: '22', destination_port_range: '22', source_address_prefix: '0.0.0.0/0', destination_address_prefix: '0.0.0.0/0', access: Fog::ARM::Network::Models::SecurityRuleAccess::Allow, priority: '100', direction: Fog::ARM::Network::Models::SecurityRuleDirection::Inbound )
List Network Security Rules¶ ↑
List all the network security rules in a resource group and network security group
network_security_rules = azure_network_service.network_security_rules(resource_group: '<Resource Group name>', network_security_group_name: '<Network Security Group name>') network_security_rules.each do |network_security_rule| puts network_security_rule.name end
Retrieve a single Network Security Rule¶ ↑
Get a single record of Network Security Rule
network_security_rule = azure_network_service .network_security_rules .get(<Resource Group Name>','<Network Security Group name>', '<Security Rule name>') puts "#{network_security_rule.name}"
Destroy a Network Security Rule¶ ↑
Get a network security rule object from the get method and then destroy that network security rule.
network_security_rule.destroy
Check External Load Balancer Existence¶ ↑
azure_network_service.load_balancers.check_load_balancer_exists(<Resource Group name>, <Load Balancer name>)
Create External Load Balancer¶ ↑
Create a new load balancer.
lb = azure_network_service.load_balancers.create( name: '<Load Balancer name>', resource_group: '<Resource Group name>', location: 'westus', frontend_ip_configurations: [ { name: 'fic', private_ipallocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic, public_ipaddress_id: '/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/publicIPAddresses/<Public-IP-Name>' } ], backend_address_pool_names: [ 'pool1' ], load_balancing_rules: [ { name: 'lb_rule_1', frontend_ip_configuration_id: '/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/loadBalancers/<Load Balancer name>/frontendIPConfigurations/fic', backend_address_pool_id: '/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/loadBalancers/<Load Balancer name>/backendAddressPools/pool1', protocol: 'Tcp', frontend_port: '80', backend_port: '8080', enable_floating_ip: false, idle_timeout_in_minutes: 4, load_distribution: "Default" } ], inbound_nat_rules: [ { name: 'RDP-Traffic', frontend_ip_configuration_id: '/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/loadBalancers/<Load Balancer name>/frontendIPConfigurations/fic', protocol: 'Tcp', frontend_port: 3389, backend_port: 3389 } ] )
Create Internal Load Balancer¶ ↑
lb = azure_network_service.load_balancers.create( name: '<Load Balancer name>', resource_group: '<Resource Group name>', location: 'westus', frontend_ip_configurations: [ { name: 'LB-Frontend', private_ipallocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Static, private_ipaddress: '10.1.2.5', subnet_id: subnet.id } ], backend_address_pool_names: [ 'LB-backend' ], load_balancing_rules: [ { name: 'HTTP', frontend_ip_configuration_id: "/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/loadBalancers/<Load-Balancer-Name>/frontendIPConfigurations/LB-Frontend", backend_address_pool_id: "/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/loadBalancers/<Load-Balancer-Name>/backendAddressPools/LB-backend", probe_id: "/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/loadBalancers<Load-Balancer-Name>lb/probes/HealthProbe", protocol: 'Tcp', frontend_port: '80', backend_port: '80' } ], inbound_nat_rules: [ { name: 'RDP1', frontend_ip_configuration_id: "/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/loadBalancers/<Load-Balancer-Name>/frontendIPConfigurations/LB-Frontend", protocol: 'Tcp', frontend_port: 3441, backend_port: 3389 }, { name: 'RDP2', frontend_ip_configuration_id: "/subscriptions/<Subscriptionid>/resourceGroups/<Resource Group name>/providers/Microsoft.Network/loadBalancers/<Load-Balancer-Name>/frontendIPConfigurations/LB-Frontend", protocol: 'Tcp', frontend_port: 3442, backend_port: 3389 } ], probes: [ { name: 'HealthProbe', protocol: 'http', request_path: 'HealthProbe.aspx', port: '80', interval_in_seconds: 15, number_of_probes: 2 } ] )
List Load Balancers¶ ↑
List all load balancers in a resource group
lbs = azure_network_service.load_balancers(resource_group: '<Resource Group name>') lbs.each do |lb| puts "#{lb.name}" end
List Load Balancers in subscription¶ ↑
List all load balancers in a subscription
lbs = azure_network_service.load_balancers lbs.each do |lb| puts "#{lb.name}" end
Retrieve a single Load Balancer¶ ↑
Get a single record of Load Balancer
lb = azure_network_service .load_balancers .get('<Resource Group name>', '<Load Balancer name>') puts "#{lb.name}"
Destroy a Load Balancer¶ ↑
Get a load balancer object from the get method and then destroy that load balancer.
lb.destroy
Check Virtual Network Gateway Existence¶ ↑
azure_network_service.virtual_network_gateways.check_vnet_gateway_exists(<Resource Group name>, <Virtual Network Gateway Name>)
Create Virtual Network Gateway¶ ↑
Create a new Virtual Network Gateway.
network_gateway = network.virtual_network_gateways.create( name: '<Virtual Network Gateway Name>', location: 'eastus', tags: { key1: 'value1', key2: 'value2' }, ip_configurations: [ { name: 'default', private_ipallocation_method: Fog::ARM::Network::Models::IPAllocationMethod::Dynamic, public_ipaddress_id: '/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Network/publicIPAddresses/{public_ip_name}', subnet_id: '/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Network/virtualNetworks/{virtual_network_name}/subnets/{subnet_name}', private_ipaddress: nil } ], resource_group: 'learn_fog', sku_name: 'Standard', sku_tier: 'Standard', sku_capacity: 2, gateway_type: 'ExpressRoute', enable_bgp: true, gateway_size: nil, asn: 100, bgp_peering_address: nil, peer_weight: 3, vpn_type: 'RouteBased', vpn_client_address_pool: [], gateway_default_site: '/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Network/localNetworkGateways/{local_network_gateway_name}', default_sites: [], vpn_client_configuration: { address_pool: ['192.168.0.4', '192.168.0.5'], root_certificates: [ { name: 'root', public_cert_data: 'certificate data' } ], revoked_certificates: [ { name: 'revoked', thumbprint: 'thumb print detail' } ] } )
List Virtual Network Gateways¶ ↑
List all virtual network gateways in a resource group
network_gateways = network.virtual_network_gateways(resource_group: '<Resource Group Name>') network_gateways.each do |gateway| puts "#{gateway.name}" end
Retrieve single Virtual Network Gateway¶ ↑
Get single record of Virtual Network Gateway
network_gateway = network.virtual_network_gateways.get('<Resource Group Name>', '<Virtual Network Gateway Name>') puts "#{network_gateway.name}"
Destroy single Virtual Network Gateway¶ ↑
Get a virtual network gateway object from the get method and then destroy that virtual network gateway.
network_gateway.destroy
Check Local Network Gateway Existence¶ ↑
azure_network_service.local_network_gateways.check_local_net_gateway_exists(<Resource Group name>, <Local Network Gateway Name>)
Create Local Network Gateway¶ ↑
Create a new Local Network Gateway.
local_network_gateway = network.local_network_gateways.create( name: "<Local Network Gateway Name>", location: "eastus", tags: { key1: "value1", key2: "value2" }, resource_group: "<Resource Group Name>", gateway_ip_address: '192.168.1.1', local_network_address_space_prefixes: [], asn: 100, bgp_peering_address: '192.168.1.2', peer_weight: 3 )
List Local Network Gateways¶ ↑
List all local network gateways in a resource group
local_network_gateways = network.local_network_gateways(resource_group: '<Resource Group Name>') local_network_gateways.each do |gateway| puts "#{gateway.name}" end
Retrieve single Local Network Gateway¶ ↑
Get single record of Local Network Gateway
local_network_gateway = network.local_network_gateways.get('<Resource Group Name>', '<Local Network Gateway Name>') puts "#{local_network_gateway.name}"
Destroy single Local Network Gateway¶ ↑
Get a local network gateway object from the get method and then destroy that local network gateway.
local_network_gateway.destroy
Express Route¶ ↑
Microsoft Azure ExpressRoute lets you extend your on-premises networks into the Microsoft cloud over a dedicated private connection facilitated by a connectivity provider. For more details about express route click here.
Express Route Circuit¶ ↑
The Circuit represents the entity created by customer to register with an express route service provider with intent to connect to Microsoft.
Check Express Route Circuit Existence¶ ↑
azure_network_service.express_route_circuits.check_express_route_circuit_exists(<Resource Group name>, <Circuit Name>)
Create an Express Route Circuit¶ ↑
Create a new Express Route Circuit.
circuit = network.express_route_circuits.create( "name": "<Circuit Name>", "location": "eastus", "resource_group": "<Resource Group Name>", "tags": { "key1": 'value1', "key2": 'value2' }, "sku_name": "Standard_MeteredData", "sku_tier": "Standard", "sku_family": "MeteredData", "service_provider_name": "Telenor", "peering_location": "London", "bandwidth_in_mbps": 100, "peerings": [ { "name": "AzurePublicPeering", "peering_type": "AzurePublicPeering", "peer_asn": 100, "primary_peer_address_prefix": "192.168.1.0/30", "secondary_peer_address_prefix": "192.168.2.0/30", "vlan_id": 200 } ] )
List Express Route Circuits¶ ↑
List all express route circuits in a resource group
circuits = network.express_route_circuits(resource_group: '<Resource Group Name>') circuits.each do |circuit| puts "#{circuit.name}" end
Retrieve a single Express Route Circuit¶ ↑
Get a single record of Express Route Circuit
circuit = network.express_route_circuits.get("<Resource Group Name>", "<Circuit Name>") puts "#{circuit.name}"
Destroy a single Express Route Circuit¶ ↑
Get an express route circuit object from the get method and then destroy that express route circuit.
circuit.destroy
Express Route Authorization¶ ↑
Authorization is part of Express Route circuit.
Check Express Route Circuit Authorization Existence¶ ↑
azure_network_service.express_route_circuit_authorizations.check_express_route_cir_auth_exists(<Resource Group name>, <Circuit Name>, <Authorization-Name>)
Create an Express Route Circuit Authorization¶ ↑
Create a new Express Route Circuit Authorization. Parameter 'authorization_status' can be 'Available' or 'InUse'.
authorization = network.express_route_circuit_authorizations.create( "resource_group": "<Resourse Group Name>", "name": "<Resource-Unique-Name>", "circuit_name": "<Circuit Name>", "authorization_status": "Available", "authorization_name": "<Authorization-Name>", )
List Express Route Circuit Authorizations¶ ↑
List all express route circuit authorizations in a resource group.
authorizations = network.express_route_circuit_authorizations(resource_group: '<Resource Group Name>', circuit_name: '<Circuit Name>') authorizations.each do |authorization| puts "#{authorization.name}" end
Retrieve single Express Route Circuit Authorization¶ ↑
Get a single record of Express Route Circuit Authorization.
authorization = network.express_route_circuit_authorizations.get("<Resource Group Name>", "Circuit Name", "Authorization Name") puts "#{authorization.name}"
Destroy single Express Route Circuit Authorization¶ ↑
Get an express route circuit authorization object from the get method and then destroy that express route circuit authorization.
authorization.destroy
Express Route Peering¶ ↑
BGP Peering is part of Express Route circuit and defines the type of connectivity needed with Microsoft.
Create an Express Route Circuit Peering¶ ↑
Create a new Express Route Circuit Peering.
peering = network.express_route_circuit_peerings.create( "name": "AzurePrivatePeering", "circuit_name": "<Circuit Name>", "resource_group": "<Resourse Group Name>", "peering_type": "AzurePrivatePeering", "peer_asn": 100, "primary_peer_address_prefix": "192.168.3.0/30", "secondary_peer_address_prefix": "192.168.4.0/30", "vlan_id": 200 )
List Express Route Circuit Peerings¶ ↑
List all express route circuit peerings in a resource group
peerings = network.express_route_circuit_peerings(resource_group: '<Resource Group Name>', circuit_name: '<Circuit Name>') peerings.each do |peering| puts "#{peering.name}" end
Retrieve single Express Route Circuit Peering¶ ↑
Get a single record of Express Route Circuit Peering
peering = network.express_route_circuit_peerings.get("<Resource Group Name>", "<Peering Name>", "Circuit Name") puts "#{peering.peering_type}"
Destroy single Express Route Circuit Peering¶ ↑
Get an express route circuit peering object from the get method and then destroy that express route circuit peering.
peering.destroy
Express Route Service Provider¶ ↑
Express Route Service Providers are telcos and exchange providers who are approved in the system to provide Express Route connectivity.
List Express Route Service Providers¶ ↑
List all express route service providers
service_providers = network.express_route_service_providers puts service_providers
Check Virtual Network Gateway Connection Existence¶ ↑
azure_network_service.virtual_network_gateway_connections.check_vnet_gateway_connection_exists(<Resource Group name>, <Virtual Network Gateway Connection Name>)
Create Virtual Network Gateway Connection¶ ↑
Create a new Virtual Network Gateway Connection.
gateway_connection = network.virtual_network_gateway_connections.create( name: '<Virtual Network Gateway Connection Name>', location: 'eastus', tags: { key1: 'value1', key2: 'value2' }, resource_group: '<Resource Group Name>', virtual_network_gateway1: { name: 'firstgateway', resource_group: '<Resource Group Name>' }, virtual_network_gateway2: { name: 'secondgateway', resource_group: '<Resource Group Name>' } connection_type: 'VNet-to-VNet' )
List Virtual Network Gateway Connections¶ ↑
List all virtual network gateway connections in a resource group
gateway_connections = network.virtual_network_gateway_connections(resource_group: '<Resource Group Name>') gateway_connections.each do |connection| puts "#{connection.name}" end
Retrieve single Virtual Network Gateway Connection¶ ↑
Get single record of Virtual Network Gateway Connection
gateway_connection = network.virtual_network_gateway_connections.get('<Resource Group Name>', '<Virtual Network Gateway Connection Name>') puts "#{gateway_connection.name}"
Destroy single Virtual Network Gateway Connection¶ ↑
Get a virtual network gateway connection object from the get method and then destroy that virtual network gateway connection.
gateway_connection.destroy
Get the shared key for a connection¶ ↑
shared_key = network.get_connection_shared_key('<Resource Group Name>', '<Virtual Network Gateway Connection Name>') puts gateway_connection
Set the shared key for a connection¶ ↑
network.set_connection_shared_key('<Resource Group Name>', '<Virtual Network Gateway Connection Name>', 'Value')
Reset the shared key for a connection¶ ↑
network.reset_connection_shared_key('<Resource Group Name>', '<Virtual Network Gateway Connection Name>', <Key Length in Integer>)
Support and Feedback¶ ↑
Your feedback is highly appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.