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 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_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) # 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)