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 resource group name
self.h = Haikunator()
self.rgname = self.h.haikunate()
# 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)
# generate vnet name
self.vnet = self.h.haikunate(delimiter='')
# generate public ip address names
self.ipname = self.vnet + 'ip'
self.lbipname = self.vnet + 'lbip'
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as config_data:
config_data = json.load(config_data)
except FileNotFoundError:
sys.exit("Error: Expecting azurermconfig.json in current folder")
self.tenant_id = config_data['tenantId']
self.app_id = config_data['appId']
app_secret = config_data['appSecret']
self.subscription_id = config_data['subscriptionId']
self.access_token = azurerm.get_access_token(self.tenant_id,
self.app_id, app_secret)
self.location = config_data['location']
h = Haikunator()
self.rgname = h.haikunate()
self.vault_name = h.haikunate()
self.secret_name = h.haikunate()
self.secret_value = h.haikunate()
# 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)
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']
# create resource names
h = Haikunator()
self.rgname = h.haikunate()
self.service_name = h.haikunate(delimiter='')
self.agent_dns = h.haikunate(delimiter='')
self.master_dns = h.haikunate(delimiter='')
# generate RSA Key for container service
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)
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']
# create resource names
h = Haikunator()
self.rgname = h.haikunate()
self.service_name = h.haikunate(delimiter='')
self.agent_dns = h.haikunate(delimiter='')
self.master_dns = h.haikunate(delimiter='')
# generate RSA Key for container service
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)
def test_resource_groups(self):
# 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)
# get resource group
print('Getting resource group: ' + self.rgname)
response = azurerm.get_resource_group(self.access_token,
self.subscription_id,
self.rgname)
self.assertEqual(response['name'], self.rgname)
# list resource groups
print('List resource groups: ' + self.rgname)
response = azurerm.list_resource_groups(self.access_token,
self.subscription_id)
self.assertTrue('value' in response)
# delete resource group
print('Deleting resource group: ' + self.rgname)
response = azurerm.delete_resource_group(self.access_token,
self.subscription_id,
self.rgname)
self.assertEqual(response.status_code, 202)
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 resource group name
self.rgname = Haikunator.haikunate()
# 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)
# generate vnet name
self.vnet = Haikunator.haikunate(delimiter='')
# generate public ip address names
self.ipname = self.vnet + 'ip'
self.lbipname = self.vnet + 'lbip'
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as config_file:
config_data = json.load(config_file)
except FileNotFoundError:
print("Error: Expecting vmssConfig.json in current folder")
sys.exit()
tenant_id = config_data['tenantId']
app_id = config_data['appId']
app_secret = config_data['appSecret']
self.subscription_id = config_data['subscriptionId']
self.access_token = azurerm.get_access_token(
tenant_id, app_id, app_secret)
# self.location = config_data['location'] # comment out during preview
self.location = 'westus'
# create resource names
haik = Haikunator()
self.rgname = haik.haikunate()
self.container_name = haik.haikunate(delimiter='')
self.container_name2 = haik.haikunate(delimiter='')
self.container_group_name = haik.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)
def test_linux(linux_image, auth_type, local_naming_infix, wl):
return_val = False
rg_name = local_naming_infix + "rg"
dep_name = local_naming_infix[0:20] + "dep"
res = azurerm.create_resource_group(access_token, subscription_id, rg_name,
'westus')
cur_parameters_json = copy.deepcopy(parameters_json[auth_type])
if wl == "l":
cur_parameters_json["image"] = {"value": linux_image}
cur_parameters_json["authenticationType"] = {"value": auth_type}
json_string = linux_json_string
else:
cur_parameters_json["WindowsServerVersion"] = {"value": linux_image}
json_string = windows_json_string
#print(local_naming_infix)
cur_parameters_json["vmssName"] = {"value": local_naming_infix}
cur_parameters_json_string = json.dumps(cur_parameters_json)
res = azurerm.deploy_template(access_token, subscription_id, rg_name,
dep_name, json_string,
cur_parameters_json_string)
#print(res.text)
while True:
time.sleep(10)
res = azurerm.show_deployment(access_token, subscription_id, rg_name,
dep_name)
if "properties" not in res:
print("properties not in res")
print(res)
else:
if res["properties"]["provisioningState"] == "Failed":
#print("provisioning state failed")
break
if res["properties"]["provisioningState"] == "Succeeded":
return_val = True
break
res = azurerm.delete_resource_group(access_token, subscription_id, rg_name)
return return_val
def test_linux(linux_image, auth_type, local_naming_infix, wl):
return_val = False
rg_name = local_naming_infix + "rg"
dep_name = local_naming_infix[0:20] + "dep"
res = azurerm.create_resource_group(access_token, subscription_id, rg_name, 'westus')
cur_parameters_json = copy.deepcopy(parameters_json[auth_type])
if wl == "l":
cur_parameters_json["image"] = {"value": linux_image}
cur_parameters_json["authenticationType"] = {"value": auth_type}
json_string = linux_json_string
else:
cur_parameters_json["WindowsServerVersion"] = {"value": linux_image}
json_string = windows_json_string
#print(local_naming_infix)
cur_parameters_json["vmssName"] = {"value": local_naming_infix}
cur_parameters_json_string = json.dumps(cur_parameters_json)
res = azurerm.deploy_template(access_token, subscription_id, rg_name, dep_name, json_string, cur_parameters_json_string)
#print(res.text)
while True:
time.sleep(10)
res = azurerm.show_deployment(access_token, subscription_id, rg_name, dep_name)
if "properties" not in res:
print("properties not in res")
print(res)
else:
if res["properties"]["provisioningState"] == "Failed":
#print("provisioning state failed")
break
if res["properties"]["provisioningState"] == "Succeeded":
return_val = True
break
res = azurerm.delete_resource_group(access_token, subscription_id, rg_name)
return return_val
def test_resource_groups(self):
# 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 Cosmos DB account
print('Creating Cosmos DB account: ' + self.cosmosdbname)
response = azurerm.create_cosmosdb_account(self.access_token, self.subscription_id, self.rgname, \
self.cosmosdbname, self.location, cosmosdb_kind='GlobalDocumentDB')
self.assertEqual(response.status_code, 200)
# delete resource group
print('Deleting resource group: ' + self.rgname)
response = azurerm.delete_resource_group(self.access_token,
self.subscription_id,
self.rgname)
self.assertEqual(response.status_code, 202)
def test_resource_groups(self):
# 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)
# get resource group
print('Getting resource group: ' + self.rgname)
response = azurerm.get_resource_group(self.access_token, self.subscription_id, self.rgname)
self.assertEqual(response['name'], self.rgname)
# list resource groups
print('List resource groups: ' + self.rgname)
response = azurerm.list_resource_groups(self.access_token, self.subscription_id)
self.assertTrue('value' in response)
# delete resource group
print('Deleting resource group: ' + self.rgname)
response = azurerm.delete_resource_group(self.access_token, self.subscription_id, self.rgname)
self.assertEqual(response.status_code, 202)
def test_resource_groups(self):
# 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)
# get resource group
print('Getting resource group: ' + self.rgname)
response = azurerm.get_resource_group(self.access_token,
self.subscription_id,
self.rgname)
self.assertEqual(response['name'], self.rgname)
# export resource group
print('Exporting resource group: ' + self.rgname)
response = azurerm.export_template(self.access_token,
self.subscription_id, self.rgname)
self.assertEqual(response.status_code, 200)
# get resource group resources
print('Getting resources for resource group: ' + self.rgname)
response = azurerm.get_resource_group_resources(
self.access_token, self.subscription_id, self.rgname)
#print(json.dumps(response, sort_keys=False, indent=2, separators=(',', ': ')))
self.assertTrue('value' in response)
# list resource groups
print('List resource groups: ' + self.rgname)
response = azurerm.list_resource_groups(self.access_token,
self.subscription_id)
self.assertTrue('value' in response)
# delete resource group
print('Deleting resource group: ' + self.rgname)
response = azurerm.delete_resource_group(self.access_token,
self.subscription_id,
self.rgname)
self.assertEqual(response.status_code, 202)
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"]
self.rgname = Haikunator.haikunate()
# 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)
# storage account name
self.storage_account = Haikunator.haikunate(delimiter="")
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']
subscription_id = configData['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(rmreturn)
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=(',', ': ')))
import json
import azurerm
# 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']
subscription_id = configData['subscriptionId']
access_token = azurerm.get_access_token(
tenant_id,
app_id,
app_secret
)
# create a resource group
print('Enter Resource group name to create.')
rgname = input()
location = 'eastus'
rgreturn = azurerm.create_resource_group(access_token, subscription_id, rgname, location)
print(rgreturn)
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)
'''create_rg.py - Create an Azure resource group'''
import json
import sys
import azurerm
# 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']
SUB_ID = CONFIG_DATA['subscriptionId']
ACCESS_TOKEN = azurerm.get_access_token(TENANT_ID, APP_ID, APP_SECRET)
# create a resource group
print('Enter Resource group name to create.')
RGNAME = input()
LOCATION = 'eastus'
RET = azurerm.create_resource_group(ACCESS_TOKEN, SUB_ID, RGNAME, LOCATION)
print(RET)
def main():
'''Main routine.'''
# validate command line arguments
argparser = argparse.ArgumentParser()
argparser.add_argument('--uri',
'-u',
required=True,
action='store',
help='Template URI')
argparser.add_argument('--params',
'-f',
required=True,
action='store',
help='Parameters json file')
argparser.add_argument('--location',
'-l',
required=True,
action='store',
help='Location, e.g. eastus')
argparser.add_argument('--rg',
'-g',
required=False,
action='store',
help='Resource Group name')
argparser.add_argument('--sub',
'-s',
required=False,
action='store',
help='Subscription ID')
argparser.add_argument(
'--genparams',
'-p',
required=False,
action='store',
help='Comma separated list of parameters to generate strings for')
argparser.add_argument('--wait',
'-w',
required=False,
action='store_true',
default=False,
help='Wait for deployment to complete and time it')
argparser.add_argument('--debug',
'-d',
required=False,
action='store_true',
default=False,
help='Debug mode: print additional deployment')
args = argparser.parse_args()
template_uri = args.uri
params = args.params
rgname = args.rg
location = args.location
subscription_id = args.sub
# Load Azure app defaults
try:
with open('azurermconfig.json') as configfile:
configdata = json.load(configfile)
except FileNotFoundError:
sys.exit('Error: Expecting azurermconfig.json in current folder')
tenant_id = configdata['tenantId']
app_id = configdata['appId']
app_secret = configdata['appSecret']
if subscription_id is None:
subscription_id = configdata['subscriptionId']
# authenticate
access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
# load parameters file
try:
with open(params) as params_file:
param_data = json.load(params_file)
except FileNotFoundError:
sys.exit('Error: Expecting ' + params + ' in current folder')
# prep Haikunator
haikunator = Haikunator()
# if there is a genparams argument generate values and merge the list
if args.genparams is not None:
newdict = {}
genlist = args.genparams.split(',')
for param in genlist:
# generate a random prhase, include caps and puncs in case it's a passwd
newval = haikunator.haikunate(delimiter='-').title()
newdict[param] = {'value': newval}
params = {**param_data, **newdict}
else:
params = param_data
# create resource group if not specified
if rgname is None:
rgname = haikunator.haikunate()
ret = azurerm.create_resource_group(access_token, subscription_id,
rgname, location)
print('Creating resource group: ' + rgname + ', location:',
location + ', return code:', ret)
deployment_name = haikunator.haikunate()
# measure time from beginning of deployment call (after creating resource group etc.)
start_time = time.time()
# deploy template and print response
deploy_return = azurerm.deploy_template_uri(access_token, subscription_id,
rgname, deployment_name,
template_uri, params)
print('Deployment name: ' + deployment_name + ', return code:',
deploy_return)
if 'Response [20' not in str(deploy_return):
print('Return from deployment: ', deploy_return.text)
sys.exit('Deployment failed. Exiting.. ')
if args.debug is True:
print(
json.dumps(deploy_return.json(),
sort_keys=False,
indent=2,
separators=(',', ': ')))
# show deployment status
if args.debug is True:
print('Deployment status:')
deploy_return = azurerm.show_deployment(access_token, subscription_id,
rgname, deployment_name)
print(
json.dumps(deploy_return,
sort_keys=False,
indent=2,
separators=(',', ': ')))
# wait for deployment to complete
if args.wait is True:
print('Waiting for provisioning to complete..')
provisioning_state = ''
try:
while True:
time.sleep(10)
deploy_return = azurerm.show_deployment(
access_token, subscription_id, rgname, deployment_name)
provisioning_state = deploy_return['properties'][
'provisioningState']
if provisioning_state != 'Running':
break
print('Provisioning state:', provisioning_state)
except KeyError:
print('Deployment failure:', deploy_return)
elapsed_time = time.time() - start_time
print('Elapsed time:', elapsed_time)
def main():
'''Main routine.'''
# validate command line arguments
argparser = argparse.ArgumentParser()
argparser.add_argument('--uri', '-u', required=True,
action='store', help='Template URI')
argparser.add_argument('--params', '-f', required=True,
action='store', help='Parameters json file')
argparser.add_argument('--location', '-l', required=True,
action='store', help='Location, e.g. eastus')
argparser.add_argument('--rg', '-g', required=False,
action='store', help='Resource Group name')
argparser.add_argument('--sub', '-s', required=False,
action='store', help='Subscription ID')
argparser.add_argument('--genparams', '-p', required=False,
action='store', help='Comma separated list of parameters to generate strings for')
argparser.add_argument('--wait', '-w', required=False, action='store_true', default=False,
help='Wait for deployment to complete and time it')
argparser.add_argument('--debug', '-d', required=False, action='store_true', default=False,
help='Debug mode: print additional deployment')
args = argparser.parse_args()
template_uri = args.uri
params = args.params
rgname = args.rg
location = args.location
subscription_id = args.sub
# Load Azure app defaults
try:
with open('azurermconfig.json') as configfile:
configdata = json.load(configfile)
except FileNotFoundError:
sys.exit('Error: Expecting azurermconfig.json in current folder')
tenant_id = configdata['tenantId']
app_id = configdata['appId']
app_secret = configdata['appSecret']
if subscription_id is None:
subscription_id = configdata['subscriptionId']
# authenticate
access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
# load parameters file
try:
with open(params) as params_file:
param_data = json.load(params_file)
except FileNotFoundError:
sys.exit('Error: Expecting ' + params + ' in current folder')
# prep Haikunator
haikunator = Haikunator()
# if there is a genparams argument generate values and merge the list
if args.genparams is not None:
newdict = {}
genlist = args.genparams.split(',')
for param in genlist:
# generate a random prhase, include caps and puncs in case it's a passwd
newval = haikunator.haikunate(delimiter='-').title()
newdict[param] = {'value': newval}
params = {**param_data, **newdict}
else:
params = param_data
# create resource group if not specified
if rgname is None:
rgname = haikunator.haikunate()
ret = azurerm.create_resource_group(
access_token, subscription_id, rgname, location)
print('Creating resource group: ' + rgname +
', location:', location + ', return code:', ret)
deployment_name = haikunator.haikunate()
# measure time from beginning of deployment call (after creating resource group etc.)
start_time = time.time()
# deploy template and print response
deploy_return = azurerm.deploy_template_uri(
access_token, subscription_id, rgname, deployment_name, template_uri, params)
print('Deployment name: ' + deployment_name +
', return code:', deploy_return)
if 'Response [20' not in str(deploy_return):
print('Return from deployment: ', deploy_return.text)
sys.exit('Deployment failed. Exiting.. ')
if args.debug is True:
print(json.dumps(deploy_return.json(), sort_keys=False,
indent=2, separators=(',', ': ')))
# show deployment status
if args.debug is True:
print('Deployment status:')
deploy_return = azurerm.show_deployment(
access_token, subscription_id, rgname, deployment_name)
print(json.dumps(deploy_return, sort_keys=False,
indent=2, separators=(',', ': ')))
# wait for deployment to complete
if args.wait is True:
print('Waiting for provisioning to complete..')
provisioning_state = ''
try:
while True:
time.sleep(10)
deploy_return = azurerm.show_deployment(
access_token, subscription_id, rgname, deployment_name)
provisioning_state = deploy_return['properties']['provisioningState']
if provisioning_state != 'Running':
break
print('Provisioning state:', provisioning_state)
except KeyError:
print('Deployment failure:', deploy_return)
elapsed_time = time.time() - start_time
print('Elapsed time:', elapsed_time)
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 used in tests
self.h = Haikunator()
self.rgname = self.h.haikunate()
self.vnet = self.h.haikunate()
# self.saname = self.h.haikunate(delimiter='')
self.vmname = self.h.haikunate(delimiter='')
self.vmssname = self.h.haikunate(delimiter='')
self.asname = self.h.haikunate()
# 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 VM NIC
self.ipname = self.vnet + 'ip'
print('Creating VM NIC public ip address: ' + self.ipname)
dns_label = self.vnet
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname, dns_label, self.location)
self.assertEqual(response.status_code, 201)
self.ip_id = response.json()['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 NSG
nsg_name = self.vnet + 'nsg'
print('Creating NSG: ' + nsg_name)
response = azurerm.create_nsg(self.access_token, self.subscription_id, self.rgname, \
nsg_name, self.location)
self.assertEqual(response.status_code, 201)
# print(json.dumps(response.json()))
self.nsg_id = response.json()['id']
# create NSG rule
nsg_rule = 'ssh'
print('Creating NSG rule: ' + nsg_rule)
response = azurerm.create_nsg_rule(self.access_token, self.subscription_id, self.rgname, \
nsg_name, nsg_rule, description='ssh rule', destination_range='22')
self.assertEqual(response.status_code, 201)
# create nic for VM create
nic_name = self.vnet + 'nic'
print('Creating nic: ' + nic_name)
response = azurerm.create_nic(self.access_token, self.subscription_id, self.rgname, \
nic_name, self.ip_id, self.subnet_id, self.location)
self.assertEqual(response.status_code, 201)
self.nic_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']
sys.exit()
tenant_id = configData['tenantId']
app_id = configData['appId']
app_secret = configData['appSecret']
subscription_id = configData['subscriptionId']
# authenticate
access_token = azurerm.get_access_token(tenant_id, app_id, app_secret)
location = 'eastus'
# create resource group
rgname = Haikunator.haikunate()
print('Creating resource group: ' + rgname)
response = azurerm.create_resource_group(access_token, subscription_id, rgname, location)
if response.status_code != 201:
print(json.dumps(response.json(), sort_keys=False, indent=2, separators=(',', ': ')))
sys.exit('Expecting return code 201 from create_resource_group(): ')
# create Container Service name and DNS values
service_name = Haikunator.haikunate(delimiter='')
agent_dns = Haikunator.haikunate(delimiter='')
master_dns = Haikunator.haikunate(delimiter='')
# generate RSA Key for container service
key = rsa.generate_private_key(backend=default_backend(), public_exponent=65537, \
key_size=2048)
public_key = key.public_key().public_bytes(serialization.Encoding.OpenSSH, \
serialization.PublicFormat.OpenSSH).decode('utf-8')
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 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 used in tests
self.rgname = Haikunator.haikunate()
self.vnet = Haikunator.haikunate(delimiter='')
self.saname = Haikunator.haikunate(delimiter='')
self.vmname = Haikunator.haikunate(delimiter='')
self.vmssname = 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 VM NIC
self.ipname = self.vnet + 'ip'
print('Creating VM NIC public ip address: ' + self.ipname)
dns_label = self.vnet
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname, dns_label, self.location)
self.assertEqual(response.status_code, 201)
self.ip_id = response.json()['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 storage account for VM
print('Creating storage account: ' + self.saname)
response = azurerm.create_storage_account(self.access_token, self.subscription_id, self.rgname, \
self.saname, self.location, storage_type='Standard_LRS')
self.assertEqual(response.status_code, 202)
# 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 NSG
nsg_name = self.vnet + 'nsg'
print('Creating NSG: ' + nsg_name)
response = azurerm.create_nsg(self.access_token, self.subscription_id, self.rgname, \
nsg_name, self.location)
self.assertEqual(response.status_code, 201)
# print(json.dumps(response.json()))
self.nsg_id = response.json()['id']
# create NSG rule
nsg_rule = 'ssh'
print('Creating NSG rule: ' + nsg_rule)
response = azurerm.create_nsg_rule(self.access_token, self.subscription_id, self.rgname, \
nsg_name, nsg_rule, description='ssh rule', destination_range='22')
self.assertEqual(response.status_code, 201)
# create nic for VM create
nic_name = self.vnet + 'nic'
print('Creating nic: ' + nic_name)
response = azurerm.create_nic(self.access_token, self.subscription_id, self.rgname, \
nic_name, self.ip_id, self.subnet_id, self.location)
self.assertEqual(response.status_code, 201)
self.nic_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']
def setUp(self):
# Load Azure app defaults
try:
with open('azurermconfig.json') as config_file:
config_data = json.load(config_file)
except FileNotFoundError:
sys.exit("Error: Expecting azurermconfig.json in current folder")
tenant_id = config_data['tenantId']
app_id = config_data['appId']
app_secret = config_data['appSecret']
self.subscription_id = config_data['subscriptionId']
self.access_token = azurerm.get_access_token(tenant_id, app_id,
app_secret)
self.location = config_data['location']
# generate names used in tests
self.h = Haikunator()
self.rgname = self.h.haikunate()
self.vnet = self.h.haikunate()
# self.saname = self.h.haikunate(delimiter='')
self.vmname = self.h.haikunate(delimiter='')
self.vmssname = self.h.haikunate(delimiter='')
self.asname = self.h.haikunate()
# 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 VM NIC
self.ipname = self.vnet + 'ip'
print('Creating VM NIC public ip address: ' + self.ipname)
dns_label = self.vnet
response = azurerm.create_public_ip(self.access_token, self.subscription_id, self.rgname, \
self.ipname, dns_label, self.location)
self.assertEqual(response.status_code, 201)
self.ip_id = response.json()['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 NSG
nsg_name = self.vnet + 'nsg'
print('Creating NSG: ' + nsg_name)
response = azurerm.create_nsg(self.access_token, self.subscription_id, self.rgname, \
nsg_name, self.location)
self.assertEqual(response.status_code, 201)
# print(json.dumps(response.json()))
self.nsg_id = response.json()['id']
# create NSG rule
time.sleep(5)
nsg_rule = 'ssh'
print('Creating NSG rule: ' + nsg_rule)
response = azurerm.create_nsg_rule(self.access_token, self.subscription_id, self.rgname, \
nsg_name, nsg_rule, description='ssh rule', destination_range='22')
# print(json.dumps(response.json()))
self.assertEqual(response.status_code, 201)
# create nic for VM create
# sleep long enough for subnet to finish creating
time.sleep(10)
nic_name = self.vnet + 'nic'
print('Creating nic: ' + nic_name)
response = azurerm.create_nic(self.access_token, self.subscription_id, self.rgname, \
nic_name, self.ip_id, self.subnet_id, self.location)
self.assertEqual(response.status_code, 201)
self.nic_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']
from azure.storage.table import TableService, Entity
# Define variables to handle Azure authentication
auth_token = azurerm.get_access_token_from_cli()
subscription_id = azurerm.get_subscription_from_cli()
# Define variables with random resource group and storage account names
resourcegroup_name = 'kev'+''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(6))
storageaccount_name = 'kev'+''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(6))
location = 'southcentralus'
###
# Create the a resource group for our demo
# We need a resource group and a storage account. A random name is generated, as each storage account name must be globally unique.
###
response = azurerm.create_resource_group(auth_token, subscription_id, resourcegroup_name, location)
if response.status_code == 200 or response.status_code == 201:
print('Resource group: ' + resourcegroup_name + ' created successfully.')
else:
print('Error creating resource group')
# Create a storage account for our demo
response = azurerm.create_storage_account(auth_token, subscription_id, resourcegroup_name, storageaccount_name, location, storage_type='Standard_LRS')
if response.status_code == 202:
print('Storage account: ' + storageaccount_name + ' created successfully.')
time.sleep(2)
else:
print('Error creating storage account')
###
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)
