def test_compute(self):
# create VM
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04.0-LTS'
version = 'latest'
os_uri = 'http://' + self.saname + '.blob.core.windows.net/vhds/osdisk.vhd'
username = '******'
password = Haikunator.haikunate(delimiter=',')
print('Creating VM: ' + self.vmname)
response = azurerm.create_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname, vm_size, publisher, offer, sku, version, self.saname, os_uri, \
self.nic_id, self.location, username=username, public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmname)
# create VMSS
capacity = 3
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, self.container_list, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmssname)
# get compute usage
print('Getting compute usage')
response = azurerm.get_compute_usage(self.access_token, self.subscription_id, self.location)
self.assertTrue(len(response['value']) > 0)
# get vm instance view
print('Getting VM instance view')
response = azurerm.get_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname, self.vmname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertEqual(response['statuses'][0]['displayStatus'], 'Creating')
# list vm instance views
print('Listing VM instance views')
response = azurerm.list_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# delete VM
print('Deleting VM: ' + self.vmname)
response = azurerm.delete_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname)
self.assertEqual(response.status_code, 202)
# delete VMSS
print('Deleting VMSS: ' + self.vmssname)
response = azurerm.delete_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname)
self.assertEqual(response.status_code, 202)
def test_compute(self):
# create VM
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04.0-LTS'
version = 'latest'
os_uri = 'http://' + self.saname + '.blob.core.windows.net/vhds/osdisk.vhd'
username = '******'
password = Haikunator.haikunate(delimiter=',')
print('Creating VM: ' + self.vmname)
response = azurerm.create_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname, vm_size, publisher, offer, sku, version, self.saname, os_uri, \
username, password, self.nic_id, self.location)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmname)
# create VMSS
capacity = 3
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, self.container_list, \
username, password, self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmssname)
# get compute usage
print('Getting compute usage')
response = azurerm.get_compute_usage(self.access_token, self.subscription_id, self.location)
self.assertTrue(len(response['value']) > 0)
# delete VM
print('Deleting VM: ' + self.vmname)
response = azurerm.delete_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname)
self.assertEqual(response.status_code, 202)
# delete VMSS
print('Deleting VMSS: ' + self.vmssname)
response = azurerm.delete_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname)
self.assertEqual(response.status_code, 202)
def test_compute(self):
# create availability set
print('Creating availability set: ' + self.asname +
', update domains = 5, fault domains = 3')
response = azurerm.create_as(self.access_token, self.subscription_id,
self.rgname, self.asname, 5, 3,
self.location)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['name'], self.asname)
# create VM
vm_size = 'Standard_B1s'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '18.04-LTS'
version = 'latest'
username = '******'
print('Creating VM: ' + self.vmname)
response = azurerm.create_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname, vm_size, publisher, offer, sku, version, \
self.nic_id, self.location, username=username, public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmname)
# create VMSS
capacity = 3
print('Creating VMSS: ' + self.vmssname + ', capacity = ' +
str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, \
self.subnet_id, self.location, self.be_pool_id, self.lb_pool_id, username=username, \
public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmssname)
# get compute usage
print('Getting compute usage')
response = azurerm.get_compute_usage(self.access_token,
self.subscription_id,
self.location)
self.assertTrue(len(response['value']) > 0)
# get vm instance view
print('Getting VM instance view')
response = azurerm.get_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname, self.vmname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertEqual(response['statuses'][0]['displayStatus'], 'Creating')
# get availability set details
print('Getting availability set details')
response = azurerm.get_as(self.access_token, self.subscription_id,
self.rgname, self.asname)
self.assertEqual(response['name'], self.asname)
# list VMSS skus
print('Listing VMSS skus')
response = azurerm.list_vmss_skus(self.access_token, self.subscription_id, \
self.rgname, self.vmssname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# list VMSS nics
print('Getting VMSS NICs')
response = azurerm.get_vmss_nics(self.access_token, self.subscription_id, \
self.rgname, self.vmssname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# delete VM
print('Deleting VM: ' + self.vmname)
response = azurerm.delete_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname)
self.assertEqual(response.status_code, 202)
# delete VMSS
print('Deleting VMSS: ' + self.vmssname)
response = azurerm.delete_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname)
self.assertEqual(response.status_code, 202)
# delete Availability Set
print('Deleting Availability Set: ' + self.asname)
response = azurerm.delete_as(self.access_token, self.subscription_id, self.rgname, \
self.asname)
self.assertEqual(response.status_code, 200)
rmreturn = azurerm.create_public_ip(access_token, subscription_id, name, public_ip_name, \
dns_label, location)
print(rmreturn)
ip_id = rmreturn.json()['id']
print('ip_id = ' + ip_id)
# create load balancer with nat pool
lb_name = vnetname + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
rmreturn = azurerm.create_lb_with_nat_pool(access_token, subscription_id, name, lb_name, ip_id, \
'50000', '50100', '22', location)
be_pool_id = rmreturn.json()['properties']['backendAddressPools'][0]['id']
lb_pool_id = rmreturn.json()['properties']['inboundNatPools'][0]['id']
# create VMSS
vmss_name = name
vm_size = 'Standard_A1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04-LTS'
version = 'latest'
username = '******'
password = Haikunator().haikunate(delimiter=',') # creates random password
print('Password = '******'Creating VMSS: ' + vmss_name)
rmreturn = azurerm.create_vmss(access_token, subscription_id, name, vmss_name, vm_size, capacity, \
publisher, offer, sku, version, subnet_id, be_pool_id, lb_pool_id, location, \
username=username, password=password)
print(rmreturn)
print(json.dumps(rmreturn.json(), sort_keys=False, indent=2, separators=(',', ': ')))
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
# generate names for resources
self.h = Haikunator()
self.rgname = self.h.haikunate()
self.vnet = self.h.haikunate(delimiter='')
self.vmssname = self.h.haikunate(delimiter='')
self.setting_name = self.h.haikunate(delimiter='')
# generate RSA Key for compute resources
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
self.public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
serialization.PublicFormat.OpenSSH).decode('utf-8')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# create vnet
print('Creating vnet: ' + self.vnet)
response = azurerm.create_vnet(self.access_token, self.subscription_id, self.rgname, \
self.vnet, self.location, address_prefix='10.0.0.0/16', nsg_id=None)
self.assertEqual(response.status_code, 201)
self.subnet_id = response.json()['properties']['subnets'][0]['id']
# create public ip address for VMSS LB
self.ipname2 = self.vnet + 'ip2'
print('Creating VMSS LB public ip address: ' + self.ipname2)
dns_label2 = self.vnet + '2'
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname2, dns_label2, self.location)
self.assertEqual(response.status_code, 201)
self.ip2_id = response.json()['id']
# create load balancer with nat pool for VMSS create
lb_name = self.vnet + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
response = azurerm.create_lb_with_nat_pool(self.access_token, self.subscription_id, \
self.rgname, lb_name, self.ip2_id, '50000', '50100', '22', self.location)
self.be_pool_id = response.json()['properties']['backendAddressPools'][0]['id']
self.lb_pool_id = response.json()['properties']['inboundNatPools'][0]['id']
# create VMSS
capacity = 1
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04-LTS'
version = 'latest'
username = '******'
password = self.h.haikunate(delimiter=',')
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
public_key=self.public_key)
def test_compute(self):
# create availability set
print('Creating availability set: ' + self.asname + ', update domains = 5, fault domains = 3')
response = azurerm.create_as(self.access_token, self.subscription_id, self.rgname,
self.asname, 5, 3, self.location)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['name'], self.asname)
# create VM
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04-LTS'
version = 'latest'
username = '******'
password = self.h.haikunate(',')
print('Creating VM: ' + self.vmname)
response = azurerm.create_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname, vm_size, publisher, offer, sku, version, \
self.nic_id, self.location, username=username, public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmname)
# create VMSS
capacity = 3
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmssname)
# get compute usage
print('Getting compute usage')
response = azurerm.get_compute_usage(self.access_token, self.subscription_id, self.location)
self.assertTrue(len(response['value']) > 0)
# get vm instance view
print('Getting VM instance view')
response = azurerm.get_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname, self.vmname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertEqual(response['statuses'][0]['displayStatus'], 'Creating')
# get availability set details
print('Getting availability set details')
response = azurerm.get_as(self.access_token, self.subscription_id, self.rgname, self.asname)
self.assertEqual(response['name'], self.asname)
# list vm instance views
print('Listing VM instance views')
response = azurerm.list_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# list VMSS skus
print('Listing VMSS skus')
response = azurerm.list_vmss_skus(self.access_token, self.subscription_id, \
self.rgname, self.vmssname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# list VMSS nics
print('Getting VMSS NICs')
response = azurerm.get_vmss_nics(self.access_token, self.subscription_id, \
self.rgname, self.vmssname)
#print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# delete VM
print('Deleting VM: ' + self.vmname)
response = azurerm.delete_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname)
self.assertEqual(response.status_code, 202)
# delete VMSS
print('Deleting VMSS: ' + self.vmssname)
response = azurerm.delete_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname)
self.assertEqual(response.status_code, 202)
# delete Availability Set
print('Deleting Availability Set: ' + self.asname)
response = azurerm.delete_as(self.access_token, self.subscription_id, self.rgname, \
self.asname)
self.assertEqual(response.status_code, 200)
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id,
app_secret)
self.location = configData['location']
# generate names for resources
self.h = Haikunator()
self.rgname = self.h.haikunate()
self.vnet = self.h.haikunate(delimiter='')
self.vmssname = self.h.haikunate(delimiter='')
self.setting_name = self.h.haikunate(delimiter='')
# generate RSA Key for compute resources
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
self.public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
serialization.PublicFormat.OpenSSH).decode('utf-8')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# create vnet
print('Creating vnet: ' + self.vnet)
response = azurerm.create_vnet(self.access_token, self.subscription_id, self.rgname, \
self.vnet, self.location, address_prefix='10.0.0.0/16', nsg_id=None)
self.assertEqual(response.status_code, 201)
self.subnet_id = response.json()['properties']['subnets'][0]['id']
# create public ip address for VMSS LB
self.ipname2 = self.vnet + 'ip2'
print('Creating VMSS LB public ip address: ' + self.ipname2)
dns_label2 = self.vnet + '2'
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname2, dns_label2, self.location)
self.assertEqual(response.status_code, 201)
self.ip2_id = response.json()['id']
# create load balancer with nat pool for VMSS create
lb_name = self.vnet + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
response = azurerm.create_lb_with_nat_pool(self.access_token, self.subscription_id, \
self.rgname, lb_name, self.ip2_id, '50000', '50100', '22', self.location)
self.be_pool_id = response.json(
)['properties']['backendAddressPools'][0]['id']
self.lb_pool_id = response.json(
)['properties']['inboundNatPools'][0]['id']
# create VMSS
capacity = 1
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04-LTS'
version = 'latest'
username = '******'
password = self.h.haikunate(delimiter=',')
print('Creating VMSS: ' + self.vmssname + ', capacity = ' +
str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
public_key=self.public_key)
print('ip_id = ' + ip_id)
# create load balancer with nat pool
lb_name = vnetname + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
rmreturn = azurerm.create_lb_with_nat_pool(access_token, subscription_id, name, lb_name, ip_id, \
'50000', '50100', '22', location)
be_pool_id = rmreturn.json()['properties']['backendAddressPools'][0]['id']
lb_pool_id = rmreturn.json()['properties']['inboundNatPools'][0]['id']
# create VMSS
vmss_name = name
vm_size = 'Standard_A1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04-LTS'
version = 'latest'
username = '******'
password = Haikunator().haikunate(delimiter=',') # creates random password
print('Password = '******'Creating VMSS: ' + vmss_name)
rmreturn = azurerm.create_vmss(access_token, subscription_id, name, vmss_name, vm_size, capacity, \
publisher, offer, sku, version, subnet_id, be_pool_id, lb_pool_id, location, \
username=username, password=password)
print(rmreturn)
print(
json.dumps(rmreturn.json(),
sort_keys=False,
indent=2,
separators=(',', ': ')))
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as configFile:
configData = json.load(configFile)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
self.subscription_id = configData['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
self.location = configData['location']
# generate names for resources
self.rgname = Haikunator.haikunate()
self.vnet = Haikunator.haikunate(delimiter='')
self.vmssname = Haikunator.haikunate(delimiter='')
self.setting_name = Haikunator.haikunate(delimiter='')
# create resource group
print('Creating resource group: ' + self.rgname)
response = azurerm.create_resource_group(self.access_token, self.subscription_id, \
self.rgname, self.location)
self.assertEqual(response.status_code, 201)
# create vnet
print('Creating vnet: ' + self.vnet)
response = azurerm.create_vnet(self.access_token, self.subscription_id, self.rgname, \
self.vnet, self.location, address_prefix='10.0.0.0/16', nsg_id=None)
self.assertEqual(response.status_code, 201)
self.subnet_id = response.json()['properties']['subnets'][0]['id']
# create public ip address for VMSS LB
self.ipname2 = self.vnet + 'ip2'
print('Creating VMSS LB public ip address: ' + self.ipname2)
dns_label2 = self.vnet + '2'
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname2, dns_label2, self.location)
self.assertEqual(response.status_code, 201)
self.ip2_id = response.json()['id']
# create 5 storage accounts for vmssname
print('Creating storage accounts for scale set')
self.container_list = []
for count in range(5):
sa_name = ''.join(choice(ascii_lowercase) for i in range(10))
print(sa_name)
response = azurerm.create_storage_account(self.access_token, self.subscription_id, \
self.rgname, sa_name, self.location, storage_type='Standard_LRS')
self.assertEqual(response.status_code, 202)
container = 'https://' + sa_name + '.blob.core.windows.net/' + self.vmssname + 'vhd'
self.container_list.append(container)
# create load balancer with nat pool for VMSS create
lb_name = self.vnet + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
response = azurerm.create_lb_with_nat_pool(self.access_token, self.subscription_id, \
self.rgname, lb_name, self.ip2_id, '50000', '50100', '22', self.location)
self.be_pool_id = response.json()['properties']['backendAddressPools'][0]['id']
self.lb_pool_id = response.json()['properties']['inboundNatPools'][0]['id']
# create VMSS
capacity = 1
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04.0-LTS'
version = 'latest'
username = '******'
password = Haikunator.haikunate(delimiter=',')
print('Creating VMSS: ' + self.vmssname + ', capacity = ' + str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, self.container_list, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
password=password)
def main():
'''Main routine.'''
# validate command line arguments
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--name',
'-n',
required=True,
action='store',
help='Name of vmss')
arg_parser.add_argument('--capacity',
'-c',
required=True,
action='store',
help='Number of VMs')
arg_parser.add_argument('--location',
'-l',
action='store',
help='Location, e.g. eastus')
arg_parser.add_argument('--verbose',
'-v',
action='store_true',
default=False,
help='Print operational details')
args = arg_parser.parse_args()
name = args.name
location = args.location
capacity = args.capacity
# Load Azure app defaults
try:
with open('azurermconfig.json') as config_file:
config_data = json.load(config_file)
except FileNotFoundError:
print("Error: Expecting azurermconfig.json in current folder")
sys.exit()
tenant_id = config_data['tenantId']
app_id = config_data['appId']
app_secret = config_data['appSecret']
subscription_id = config_data['subscriptionId']
# authenticate
access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
# create resource group
print('Creating resource group: ' + name)
rmreturn = azurerm.create_resource_group(access_token, subscription_id,
name, location)
print(rmreturn)
# create NSG
nsg_name = name + 'nsg'
print('Creating NSG: ' + nsg_name)
rmreturn = azurerm.create_nsg(access_token, subscription_id, name,
nsg_name, location)
nsg_id = rmreturn.json()['id']
print('nsg_id = ' + nsg_id)
# create NSG rule
nsg_rule = 'ssh'
print('Creating NSG rule: ' + nsg_rule)
rmreturn = azurerm.create_nsg_rule(access_token,
subscription_id,
name,
nsg_name,
nsg_rule,
description='ssh rule',
destination_range='22')
#print(json.dumps(rmreturn.json(), sort_keys=False, indent=2, separators=(',', ': ')))
# create VNET
vnetname = name + 'vnet'
print('Creating VNet: ' + vnetname)
rmreturn = azurerm.create_vnet(access_token,
subscription_id,
name,
vnetname,
location,
nsg_id=nsg_id)
print(rmreturn)
# print(json.dumps(rmreturn.json(), sort_keys=False, indent=2, separators=(',', ': ')))
subnet_id = rmreturn.json()['properties']['subnets'][0]['id']
print('subnet_id = ' + subnet_id)
# create public IP address
public_ip_name = name + 'ip'
dns_label = name + 'ip'
print('Creating public IP address: ' + public_ip_name)
rmreturn = azurerm.create_public_ip(access_token, subscription_id, name,
public_ip_name, dns_label, location)
print(rmreturn)
ip_id = rmreturn.json()['id']
print('ip_id = ' + ip_id)
# create load balancer with nat pool
lb_name = vnetname + 'lb'
print('Creating load balancer with nat pool: ' + lb_name)
rmreturn = azurerm.create_lb_with_nat_pool(access_token, subscription_id,
name, lb_name, ip_id, '50000',
'50100', '22', location)
be_pool_id = rmreturn.json()['properties']['backendAddressPools'][0]['id']
lb_pool_id = rmreturn.json()['properties']['inboundNatPools'][0]['id']
# create VMSS
vmss_name = name
vm_size = 'Standard_D1_v2'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04-LTS'
version = 'latest'
username = '******'
password = Haikunator().haikunate(delimiter=',') # creates random password
print('Password = '******'Creating VMSS: ' + vmss_name)
rmreturn = azurerm.create_vmss(access_token,
subscription_id,
name,
vmss_name,
vm_size,
capacity,
publisher,
offer,
sku,
version,
subnet_id,
be_pool_id,
lb_pool_id,
location,
username=username,
password=password)
print(rmreturn)
print(
json.dumps(rmreturn.json(),
sort_keys=False,
indent=2,
separators=(',', ': ')))
def test_compute(self):
# create VM
vm_size = 'Standard_D1'
publisher = 'Canonical'
offer = 'UbuntuServer'
sku = '16.04.0-LTS'
version = 'latest'
os_uri = 'http://' + self.saname + '.blob.core.windows.net/vhds/osdisk.vhd'
username = '******'
password = Haikunator.haikunate(delimiter=',')
print('Creating VM: ' + self.vmname)
response = azurerm.create_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname, vm_size, publisher, offer, sku, version, self.saname, os_uri, \
self.nic_id, self.location, username=username, public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmname)
# create VMSS
capacity = 3
print('Creating VMSS: ' + self.vmssname + ', capacity = ' +
str(capacity))
response = azurerm.create_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname, vm_size, capacity, publisher, offer, sku, version, self.container_list, \
self.subnet_id, self.be_pool_id, self.lb_pool_id, self.location, username=username, \
public_key=self.public_key)
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()['name'], self.vmssname)
# get compute usage
print('Getting compute usage')
response = azurerm.get_compute_usage(self.access_token,
self.subscription_id,
self.location)
self.assertTrue(len(response['value']) > 0)
# get vm instance view
print('Getting VM instance view')
response = azurerm.get_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname, self.vmname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertEqual(response['statuses'][0]['displayStatus'], 'Creating')
# list vm instance views
print('Listing VM instance views')
response = azurerm.list_vm_instance_view(self.access_token, self.subscription_id, \
self.rgname)
# print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue(len(response['value']) > 0)
# delete VM
print('Deleting VM: ' + self.vmname)
response = azurerm.delete_vm(self.access_token, self.subscription_id, self.rgname, \
self.vmname)
self.assertEqual(response.status_code, 202)
# delete VMSS
print('Deleting VMSS: ' + self.vmssname)
response = azurerm.delete_vmss(self.access_token, self.subscription_id, self.rgname, \
self.vmssname)
self.assertEqual(response.status_code, 202)
