def create_app_service_plan(self): ''' Creates app service plan :return: deserialized app service plan dictionary ''' self.log("Create App Service Plan {0}".format(self.plan['name'])) try: # normalize sku sku = _normalize_sku(self.plan['sku']) sku_def = SkuDescription(tier=get_sku_name(sku), name=sku, capacity=(self.plan.get( 'number_of_workers', None))) plan_def = AppServicePlan(location=self.plan['location'], app_service_plan_name=self.plan['name'], sku=sku_def, reserved=(self.plan.get( 'is_linux', None))) poller = self.web_client.app_service_plans.create_or_update( self.plan['resource_group'], self.plan['name'], plan_def) if isinstance(poller, AzureOperationPoller): response = self.get_poller_result(poller) self.log("Response : {0}".format(response)) return response.as_dict() except CloudError as ex: self.fail( "Failed to create app service plan {0} in resource group {1}: {2}" .format(self.plan['name'], self.plan['resource_group'], str(ex)))
def create_or_update_plan(self): ''' Creates app service plan :return: deserialized app service plan dictionary ''' self.log("Create App Service Plan {0}".format(self.name)) try: # normalize sku sku = _normalize_sku(self.sku) sku_def = SkuDescription(tier=get_sku_name( sku), name=sku, capacity=self.number_of_workers) plan_def = AppServicePlan( location=self.location, app_service_plan_name=self.name, sku=sku_def, reserved=self.is_linux, tags=self.tags if self.tags else None) response = self.web_client.app_service_plans.create_or_update(self.resource_group, self.name, plan_def) if isinstance(response, LROPoller) or isinstance(response, AzureOperationPoller): response = self.get_poller_result(response) self.log("Response : {0}".format(response)) return appserviceplan_to_dict(response) except CloudError as ex: self.fail("Failed to create app service plan {0} in resource group {1}: {2}".format(self.name, self.resource_group, str(ex)))
def _provision(self, params): rg_unit = ResourceGroupUnit() rg_unit.provision_if_not_exists({'name': params['resource_group_name'], 'location': params['location']}) plan_params = AppServicePlan( app_service_plan_name=params['name'], location=params['location'], sku=SkuDescription( name=params['sku_name'], capacity=1, tier=params['sku_tier']), kind='linux', target_worker_size_id=0, reserved=True) plan = self.client.app_service_plans.begin_create_or_update(params['resource_group_name'], params['name'], plan_params).result() # Deploy default autoscale rule for dedicated plans if required by the policy autoscale_params = copy.deepcopy(params.get('auto_scale', {})) if bool(autoscale_params.get('enabled')) and \ not StringUtils.equal(plan.sku, 'dynamic'): autoscale_params['name'] = 'autoscale' autoscale_params['resource_group_name'] = params['resource_group_name'] autoscale_params['service_plan_id'] = plan.id autoscale_params['location'] = plan.location ac_unit = AutoScaleUnit() ac_unit.provision(autoscale_params) return plan
def create_app_service_plan(resource_group_name, name, is_linux, sku='B1', number_of_workers=None, location=None): client = web_client_factory() sku = _normalize_sku(sku) if location is None: location = _get_location_from_resource_group(resource_group_name) #the api is odd on parameter naming, have to live with it for now sku_def = SkuDescription(tier=_get_sku_name(sku), name=sku, capacity=number_of_workers) plan_def = AppServicePlan(location, app_service_plan_name=name, sku=sku_def, reserved=(is_linux or None)) poller = client.app_service_plans.create_or_update(resource_group_name, name, plan_def) return AppServiceLongRunningOperation(creating_plan=True)(poller)
def app_service_plan(): # The next two lines will create errors. Research pdb if uncertain how to proceed (e.g. help(pdb) # If you wish to proceed with troubleshooting, comment out the next two lines. # import pdb # pdb.set_trace() # Create an App Service Plan global service_plan # RESOURCEGROUPNAME variable has not been defined. Uncomment the line below to fix this error. RESOURCEGROUPNAME = resourcegroupname service_plan_async_operation = web_client.app_service_plans.create_or_update( RESOURCEGROUPNAME, serverfarmname, AppServicePlan(app_service_plan_name=serverfarmname, location=location, sku=SkuDescription(name='F1', capacity=10, tier='Free'))) service_plan = service_plan_async_operation.result()
async def main(): log.info("Loading secrets") secrets = load_secrets() web_client, cosmosdb_client = setup_azure(secrets) db, keys, connection_string = setup_cosmosdb(cosmosdb_client, Azure.cosmosdb_name) configure_collections(Mongo.database_name, Mongo.collections, keys.primary_master_key, db.document_endpoint) app_env = deepcopy(secrets["appEnvironment"]) app_env["MajavashakkiMongoConnectionString"] = connection_string app_env["MajavaMongoPassword"] = keys.primary_master_key log.info("Creating App Service Plan") plan = web_client.app_service_plans.create_or_update( Azure.resource_group, Azure.plan_name, app_service_plan=AppServicePlan(Azure.location, Azure.plan_name, sku=SKU_B1_BASIC)).result() log.info("Creating Web App") env_pairs = [NameValuePair(k, v) for k, v in app_env.items()] site = web_client.web_apps.create_or_update( Azure.resource_group, Azure.site_name, Site(location=Azure.location, site_config=SiteConfig( app_settings=env_pairs, scm_type=ScmType.local_git, web_sockets_enabled=True, always_on=True, ))).result() log.info("Pushing code to App Service") pub_cred = web_client.web_apps.list_publishing_credentials( Azure.resource_group, Azure.site_name).result() git_url = mk_git_url(Azure.site_name, pub_cred) if "CI" in os.environ: await shell("git", "-c", "user.name='Majavashakki Deployer'", "-c", "user.email='*****@*****.**'", "commit", "--allow-empty", "-m", "Empty commit to force app service to redeploy") await shell("git", "push", "--force", git_url, "HEAD:master") log.info("Done")
def _provision(self, params): rg_unit = ResourceGroupUnit() rg_unit.provision_if_not_exists({ 'name': params['resource_group_name'], 'location': params['location'] }) plan = AppServicePlan(app_service_plan_name=params['name'], location=params['location'], sku=SkuDescription(name=params['sku_name'], capacity=1, tier=params['sku_tier']), kind='linux', target_worker_size_id=0, reserved=True) return self.client.app_service_plans.create_or_update( params['resource_group_name'], params['name'], plan).result()
def create_deploy_webapp(cmd, name, location=None, dryrun=False): import os client = web_client_factory(cmd.cli_ctx) # the code to deploy is expected to be the current directory the command is running from src_dir = os.getcwd() # if dir is empty, show a message in dry run do_deployment = False if os.listdir(src_dir) == [] else True # determine the details for app to be created from src contents lang_details = get_lang_from_content(src_dir) # we support E2E create and deploy for Node & dotnetcore, any other stack, set defaults for os & runtime # and skip deployment if lang_details['language'] is None: do_deployment = False sku = 'F1' os_val = OS_DEFAULT detected_version = '-' runtime_version = '-' else: sku = lang_details.get("default_sku") language = lang_details.get("language") is_skip_build = language.lower() == STATIC_RUNTIME_NAME os_val = "Linux" if language.lower( ) == NODE_RUNTIME_NAME else OS_DEFAULT # detect the version data = get_runtime_version_details(lang_details.get('file_loc'), language) version_used_create = data.get('to_create') detected_version = data.get('detected') runtime_version = "{}|{}".format(language, version_used_create) if \ version_used_create != "-" else version_used_create if location is None: locs = client.list_geo_regions(sku, True) available_locs = [] for loc in locs: available_locs.append(loc.geo_region_name) location = available_locs[0] # Remove spaces from the location string, incase the GeoRegion string is used loc_name = location.replace(" ", "") full_sku = get_sku_name(sku) is_linux = True if os_val == 'Linux' else False asp = "appsvc_asp_{}_{}".format(os_val, loc_name) rg_name = "appsvc_rg_{}_{}".format(os_val, loc_name) str_no_contents_warn = "" if not do_deployment: str_no_contents_warn = "[Empty directory, no deployment will be triggered]" # Resource group: check if default RG is set default_rg = cmd.cli_ctx.config.get('defaults', 'group', fallback=None) if default_rg and check_resource_group_exists(cmd, default_rg) and \ check_resource_group_supports_os(cmd, default_rg, location, is_linux): rg_name = default_rg rg_mssg = "[Using default Resource group]" else: rg_mssg = "" src_path = "{} {}".format(src_dir.replace("\\", "\\\\"), str_no_contents_warn) rg_str = "{} {}".format(rg_name, rg_mssg) dry_run_str = r""" { "name" : "%s", "serverfarm" : "%s", "resourcegroup" : "%s", "sku": "%s", "os": "%s", "location" : "%s", "src_path" : "%s", "version_detected": "%s", "version_to_create": "%s" } """ % (name, asp, rg_str, full_sku, os_val, location, src_path, detected_version, runtime_version) create_json = json.loads(dry_run_str) if dryrun: logger.warning( "Web app will be created with the below configuration,re-run command " "without the --dryrun flag to create & deploy a new app") return create_json # create RG if the RG doesn't already exist if not check_resource_group_exists(cmd, rg_name): logger.warning("Creating Resource group '%s' ...", rg_name) create_resource_group(cmd, rg_name, location) logger.warning("Resource group creation complete") else: logger.warning("Resource group '%s' already exists.", rg_name) # create asp if not check_if_asp_exists(cmd, rg_name, asp): logger.warning("Creating App service plan '%s' ...", asp) sku_def = SkuDescription(tier=full_sku, name=sku, capacity=(1 if is_linux else None)) plan_def = AppServicePlan(loc_name, app_service_plan_name=asp, sku=sku_def, reserved=(is_linux or None)) client.app_service_plans.create_or_update(rg_name, asp, plan_def) logger.warning("App service plan creation complete") else: logger.warning("App service plan '%s' already exists.", asp) # create the app if not check_app_exists(cmd, rg_name, name): logger.warning("Creating app '%s' ....", name) create_webapp(cmd, rg_name, name, asp, runtime_version if is_linux else None) logger.warning("Webapp creation complete") else: logger.warning("App '%s' already exists", name) # update create_json to include the app_url url = _get_app_url( cmd, rg_name, name) # picks the custom domain URL incase a domain is assigned if do_deployment: if not is_skip_build: # setting to build after deployment logger.warning( "Updating app settings to enable build after deployment") update_app_settings(cmd, rg_name, name, ["SCM_DO_BUILD_DURING_DEPLOYMENT=true"]) # work around until the timeout limits issue for linux is investigated & fixed # wakeup kudu, by making an SCM call _ping_scm_site(cmd, rg_name, name) logger.warning("Creating zip with contents of dir %s ...", src_dir) # zip contents & deploy zip_file_path = zip_contents_from_dir(src_dir, language) logger.warning("Preparing to deploy %s contents to app.", '' if is_skip_build else 'and build') enable_zip_deploy(cmd, rg_name, name, zip_file_path) # Remove the file afer deployment, handling exception if user removed the file manually try: os.remove(zip_file_path) except OSError: pass else: logger.warning( 'No known package (Node, ASP.NET, .NETCORE, or Static Html) ' 'found skipping zip and deploy process') create_json.update({'app_url': url}) logger.warning("All done.") return create_json
def create_deploy_webapp(cmd, name, location=None, dryrun=False): import os import json client = web_client_factory(cmd.cli_ctx) # the code to deploy is expected to be the current directory the command is running from src_dir = os.getcwd() # if dir is empty, show a message in dry run do_deployment = False if os.listdir(src_dir) == [] else True # determine the details for app to be created from src contents lang_details = get_lang_from_content(src_dir) # we support E2E create and deploy for Node & dotnetcore, any other stack, set defaults for os & runtime # and skip deployment if lang_details['language'] is None: do_deployment = False sku = 'F1' os_val = OS_DEFAULT detected_version = '-' runtime_version = '-' else: sku = lang_details.get("default_sku") language = lang_details.get("language") os_val = "Linux" if language.lower( ) == NODE_RUNTIME_NAME else OS_DEFAULT # detect the version data = get_runtime_version_details(lang_details.get('file_loc'), language) version_used_create = data.get('to_create') detected_version = data.get('detected') runtime_version = "{}|{}".format(language, version_used_create) if location is None: locs = client.list_geo_regions(sku, True) available_locs = [] for loc in locs: available_locs.append(loc.geo_region_name) location = available_locs[0] # Remove spaces from the location string, incase the GeoRegion string is used loc_name = location.replace(" ", "") full_sku = _get_sku_name(sku) is_linux = True if os_val == 'Linux' else False asp = "appsvc_asp_{}_{}".format(os_val, loc_name) rg_name = "appsvc_rg_{}_{}".format(os_val, loc_name) str_no_contents_warn = "" if not do_deployment: str_no_contents_warn = "[Empty directory, no deployment will be triggered]" # Resource group: check if default RG is set default_rg = cmd.cli_ctx.config.get('defaults', 'group', fallback=None) if default_rg and check_resource_group_supports_os(cmd, default_rg, location, is_linux): rg_name = default_rg rg_mssg = "[Using default Resource group]" else: rg_mssg = "" src_path = "{} {}".format(src_dir.replace("\\", "\\\\"), str_no_contents_warn) rg_str = "{} {}".format(rg_name, rg_mssg) dry_run_str = r""" { "name" : "%s", "serverfarm" : "%s", "resourcegroup" : "%s", "sku": "%s", "os": "%s", "location" : "%s", "src_path" : "%s", "version_detected": "%s", "version_to_create": "%s" } """ % (name, asp, rg_str, full_sku, os_val, location, src_path, detected_version, runtime_version) create_json = json.dumps(json.loads(dry_run_str), indent=4, sort_keys=True) if dryrun: logger.warning( "Web app will be created with the below configuration,re-run command " "without the --dryrun flag to create & deploy a new app") logger.warning(create_json) return None # create RG if the RG doesn't already exist if not check_resource_group_exists(cmd, rg_name): logger.warning("Creating Resource group '%s' ...", rg_name) create_resource_group(cmd, rg_name, location) logger.warning("Resource group creation complete") else: logger.warning("Resource group '%s' already exists.", rg_name) # create asp if not check_if_asp_exists(cmd, rg_name, asp): logger.warning("Creating App service plan '%s' ...", asp) sku_def = SkuDescription(tier=full_sku, name=sku, capacity=(1 if is_linux else None)) plan_def = AppServicePlan(loc_name, app_service_plan_name=asp, sku=sku_def, reserved=(is_linux or None)) client.app_service_plans.create_or_update(rg_name, asp, plan_def) logger.warning("App service plan creation complete") else: logger.warning("App service plan '%s' already exists.", asp) # create the app if not check_app_exists(cmd, rg_name, name): logger.warning("Creating app '%s' ....", name) create_webapp(cmd, rg_name, name, asp, runtime_version if is_linux else None) logger.warning("Webapp creation complete") else: logger.warning("App '%s' already exists", name) if do_deployment: # setting to build after deployment logger.warning( "Updating app settings to enable build after deployment") update_app_settings(cmd, rg_name, name, ["SCM_DO_BUILD_DURING_DEPLOYMENT=true"]) # work around until the timeout limits issue for linux is investigated & fixed # wakeup kudu, by making an SCM call import requests # work around until the timeout limits issue for linux is investigated & fixed user_name, password = _get_site_credential(cmd.cli_ctx, rg_name, name) scm_url = _get_scm_url(cmd, rg_name, name) import urllib3 authorization = urllib3.util.make_headers( basic_auth='{0}:{1}'.format(user_name, password)) requests.get(scm_url + '/api/settings', headers=authorization) logger.warning("Creating zip with contents of dir %s ...", src_dir) # zip contents & deploy zip_file_path = zip_contents_from_dir(src_dir, language) logger.warning("Deploying and building contents to app." "This operation can take some time to finish...") enable_zip_deploy(cmd, rg_name, name, zip_file_path) else: logger.warning( "No 'NODE' or 'DOTNETCORE' package detected, skipping zip and deploy process" ) logger.warning("All done. %s", create_json) return None
def create_deploy_container_app(cmd, name, source_location=None, docker_custom_image_name=None, dryrun=False, registry_rg=None, registry_name=None): # pylint: disable=too-many-statements import os import json if not source_location: # the dockerfile is expected to be in the current directory the command is running from source_location = os.getcwd() client = web_client_factory(cmd.cli_ctx) _create_new_rg = True _create_new_asp = True _create_new_app = True _create_acr_img = True if docker_custom_image_name: logger.warning('Image will be pulled from DockerHub') img_name = docker_custom_image_name _create_acr_img = False else: logger.warning( 'Source code will be uploaded and built in Azure Container Registry' ) if not registry_name: raise CLIError("--registry-name not specified") if not registry_rg: raise CLIError("--registry-rg not specified") img_name = generate_img_name(source_location) sku = 'P1V2' full_sku = get_sku_name(sku) location = 'Central US' loc_name = 'centralus' asp = "appsvc_asp_linux_{}".format(loc_name) rg_name = "appsvc_rg_linux_{}".format(loc_name) # Resource group: check if default RG is set _create_new_rg = should_create_new_rg(cmd, rg_name, True) rg_str = "{}".format(rg_name) dry_run_str = r""" { "name" : "%s", "serverfarm" : "%s", "resourcegroup" : "%s", "sku": "%s", "location" : "%s" } """ % (name, asp, rg_str, full_sku, location) create_json = json.loads(dry_run_str) if dryrun: logger.warning( "Web app will be created with the below configuration,re-run command " "without the --dryrun flag to create & deploy a new app") return create_json if _create_acr_img: logger.warning("Starting ACR build") queue_acr_build(cmd, registry_rg, registry_name, img_name, source_location) logger.warning("ACR build done. Deploying web app.") # create RG if the RG doesn't already exist if _create_new_rg: logger.warning("Creating Resource group '%s' ...", rg_name) create_resource_group(cmd, rg_name, location) logger.warning("Resource group creation complete") _create_new_asp = True else: logger.warning("Resource group '%s' already exists.", rg_name) _create_new_asp = _should_create_new_asp(cmd, rg_name, asp, location) # create new ASP if an existing one cannot be used if _create_new_asp: logger.warning("Creating App service plan '%s' ...", asp) sku_def = SkuDescription(tier=full_sku, name=sku, capacity=1) plan_def = AppServicePlan(location=loc_name, app_service_plan_name=asp, sku=sku_def, reserved=True) client.app_service_plans.create_or_update(rg_name, asp, plan_def) logger.warning("App service plan creation complete") _create_new_app = True else: logger.warning("App service plan '%s' already exists.", asp) _create_new_app = should_create_new_app(cmd, rg_name, name) # create the app if _create_new_app: logger.warning("Creating app '%s' ....", name) # TODO: Deploy without container params and update separately instead? # deployment_container_image_name=docker_custom_image_name) create_webapp(cmd, rg_name, name, asp, deployment_container_image_name=img_name) logger.warning("Webapp creation complete") else: logger.warning("App '%s' already exists", name) # Set up the container if _create_acr_img: logger.warning("Configuring ACR container settings.") registry_url = 'https://' + registry_name + '.azurecr.io' acr_img_name = registry_name + '.azurecr.io/' + img_name update_container_settings(cmd, rg_name, name, registry_url, acr_img_name) logger.warning("All done.") return create_json
tenant=os.environ["AZURE_TENANT_ID"]) ARMClient = ResourceManagementClient(credentials, subscription_id) activity_create_rg = ARMClient.resource_groups.create_or_update( resource_group_name=rg_name, parameters={"location": rg_location}) print("Resource Group ID: {}".format(activity_create_rg.id)) # Create an App Service Plan web_client = WebSiteManagementClient(credentials, subscription_id) service_plan_async_operation = web_client.app_service_plans.create_or_update( resource_group_name=rg_name, name=app_svc_plan_name, app_service_plan=AppServicePlan( kind="linux", location=rg_location, reserved= True, # Without this set, it acts like a Windows App Service Plan sku=SkuDescription(name='P1v2', capacity=1, tier='Standard'))) service_plan = service_plan_async_operation.result() print("Service Plan ID: {}".format(service_plan.id)) # Create a Python Web App site_async_operation = web_client.web_apps.create_or_update( resource_group_name=rg_name, name=site_name, site_envelope=Site(location=rg_location, server_farm_id=service_plan.id, site_config=SiteConfig( python_version="3.7", linux_fx_version="PYTHON|3.7", app_command_line="startup.txt",
def run(job, **kwargs): resource = kwargs.get("resource") create_custom_fields_as_needed() env_id = "{{ azure_env }}" resource_group = "{{ resource_group }}" web_app_name = "{{ web_app_name }}" service_plan_name = "{{ service_plan_name }}" set_progress( f"Environment {env_id} ResourceId {resource_group} And KWARGS {kwargs}" ) env = Environment.objects.get(id=env_id) rh = env.resource_handler.cast() # Clean Resource name to Azure acceptable web-app name web_app_name = web_app_name.replace(" ", "-") web_app_name = web_app_name.replace("(", "-") web_app_name = web_app_name.replace(")", "") # Connect to Azure Management Service set_progress("Connecting To Azure Management Service...") web_client = _get_client(rh) set_progress("Successfully Connected To Azure Management Service!") if service_plan_name: # User selected a pre-existing service plan, so just get it. service_plan_obj = web_client.app_service_plans.get( resource_group_name=resource_group, name=service_plan_name) else: # Auto-create a new service plan. # Use the web_app_name and append 5 random digits to have a decent probability of uniqueness. service_plan_name = web_app_name + "-{}".format( random.randint(10000, 99999)) set_progress(f"Environment {env_id}") env = Environment.objects.get(id=env_id) service_plan_async_operation = web_client.app_service_plans.create_or_update( resource_group_name=resource_group, name=service_plan_name, app_service_plan=AppServicePlan( location=env.node_location, app_service_plan_name=service_plan_name, sku=SkuDescription(name="S1", capacity=1, tier="Standard"), ), ) service_plan_async_operation.result() service_plan_obj = web_client.app_service_plans.get( resource_group_name=resource_group, name=service_plan_name) # Create Web App site_async_operation = web_client.web_apps.create_or_update( resource_group, web_app_name, Site(location=service_plan_obj.location, server_farm_id=service_plan_obj.id), ) site = site_async_operation.result() # Store Web App metadata on the resource as parameters for teardown resource.azure_web_app_name = web_app_name resource.name = web_app_name resource.azure_web_app_id = site.id resource.azure_web_app_default_host_name = site.default_host_name resource.resource_group_name = resource_group resource.azure_location = site.location resource.save() return "SUCCESS", "", ""
sharename, filename, filename, ) file_service.create_file_from_path( sharename, '', filename, filename, ) # Create an App Service Plan service_plan_async_operation = web_client.app_service_plans.create_or_update( resourcegroupname, serverfarmname, AppServicePlan(app_service_plan_name=serverfarmname, location=location, sku=SkuDescription(name='F1', capacity=10, tier='Free'))) service_plan = service_plan_async_operation.result() # Create Web-Site site_async_operation = web_client.web_apps.create_or_update( resourcegroupname, websitename, Site(location=location, server_farm_id=service_plan.id)) website = site_async_operation.result() if website.state == 'Running': print("Website http://" + website.default_host_name + " has deployed successfully.") else: print("Website not deployed successfully.") # View the new web-site before proceeding with the following steps.
def create_deploy_webapp(cmd, name, location=None, dryrun=False): import os import json client = web_client_factory(cmd.cli_ctx) sku = "S1" os_val = "Linux" language = "node" full_sku = _get_sku_name(sku) if location is None: locs = client.list_geo_regions(sku, True) available_locs = [] for loc in locs: available_locs.append(loc.geo_region_name) location = available_locs[0] # Remove spaces from the location string, incase the GeoRegion string is used loc_name = location.replace(" ", "") asp = "appsvc_asp_{}_{}".format(os_val, loc_name) rg_name = "appsvc_rg_{}_{}".format(os_val, loc_name) # the code to deploy is expected to be the current directory the command is running from src_dir = os.getcwd() # if dir is empty, show a message in dry run do_deployment = False if os.listdir(src_dir) == [] else True package_json_path = is_node_application(src_dir) str_no_contents_warn = "" if not do_deployment: str_no_contents_warn = "[Empty directory, no deployment will be triggered]" if package_json_path == '': node_version = "[No package.json file found in root directory, not a Node app?]" version_used_create = "8.0" else: with open(package_json_path) as data_file: data = json.load(data_file) node_version = data['version'] version_used_create = get_node_runtime_version_toSet() # Resource group: check if default RG is set default_rg = cmd.cli_ctx.config.get('defaults', 'group', fallback=None) if default_rg and check_resource_group_supports_linux( cmd, default_rg, location): rg_name = default_rg rg_mssg = "[Using default Resource group]" else: rg_mssg = "" runtime_version = "{}|{}".format(language, version_used_create) src_path = "{} {}".format(src_dir.replace("\\", "\\\\"), str_no_contents_warn) rg_str = "{} {}".format(rg_name, rg_mssg) dry_run_str = r""" { "name" : "%s", "serverfarm" : "%s", "resourcegroup" : "%s", "sku": "%s", "os": "%s", "location" : "%s", "src_path" : "%s", "version_detected": "%s", "version_to_create": "%s" } """ % (name, asp, rg_str, full_sku, os_val, location, src_path, node_version, runtime_version) create_json = json.dumps(json.loads(dry_run_str), indent=4, sort_keys=True) if dryrun: logger.warning( "Web app will be created with the below configuration,re-run command " "without the --dryrun flag to create & deploy a new app") logger.warning(create_json) return None # create RG if the RG doesn't already exist if not check_resource_group_exists(cmd, rg_name): logger.warning("Creating Resource group '%s' ...", rg_name) create_resource_group(cmd, rg_name, location) logger.warning("Resource group creation complete") else: logger.warning("Resource group '%s' already exists.", rg_name) # create asp if not check_if_asp_exists(cmd, rg_name, asp): logger.warning("Creating App service plan '%s' ...", asp) sku_def = SkuDescription(tier=full_sku, name=sku, capacity=1) plan_def = AppServicePlan(loc_name, app_service_plan_name=asp, sku=sku_def, reserved=True) client.app_service_plans.create_or_update(rg_name, asp, plan_def) logger.warning("App service plan creation complete") else: logger.warning("App service plan '%s' already exists.", asp) # create the Linux app if not check_app_exists(cmd, rg_name, name): logger.warning("Creating app '%s' ....", name) create_webapp(cmd, rg_name, name, asp, runtime_version) logger.warning("Webapp creation complete") else: logger.warning("App '%s' already exists", name) # setting to build after deployment logger.warning("Updating app settings to enable build after deployment") update_app_settings(cmd, rg_name, name, ["SCM_DO_BUILD_DURING_DEPLOYMENT=true"]) # work around until the timeout limits issue for linux is investigated & fixed # wakeup kudu, by making an SCM call import requests # work around until the timeout limits issue for linux is investigated & fixed user_name, password = _get_site_credential(cmd.cli_ctx, rg_name, name) scm_url = _get_scm_url(cmd, rg_name, name) import urllib3 authorization = urllib3.util.make_headers( basic_auth='{0}:{1}'.format(user_name, password)) requests.get(scm_url + '/api/settings', headers=authorization) if package_json_path != '': logger.warning("Creating zip with contents of dir %s ...", src_dir) # zip contents & deploy zip_file_path = zip_contents_from_dir(src_dir) logger.warning("Deploying and building contents to app." "This operation can take some time to finish...") enable_zip_deploy(cmd, rg_name, name, zip_file_path) else: logger.warning( "No package.json found, skipping zip and deploy process") logger.warning("All done. %s", create_json) return None
def run_example(): """Web Site management example.""" # # Create the Resource Manager Client with an Application (service principal) token provider # subscription_id = os.environ['AZURE_SUBSCRIPTION_ID'] credentials = ServicePrincipalCredentials( client_id=os.environ['AZURE_CLIENT_ID'], secret=os.environ['AZURE_CLIENT_SECRET'], tenant=os.environ['AZURE_TENANT_ID']) resource_client = ResourceManagementClient(credentials, subscription_id) web_client = WebSiteManagementClient(credentials, subscription_id) # Create Resource group print('Create Resource Group') resource_group_params = {'location': 'westus'} print_item( resource_client.resource_groups.create_or_update( GROUP_NAME, resource_group_params)) # # Create an App Service plan for your WebApp # print('Create an App Service plan for your WebApp') service_plan_async_operation = web_client.app_service_plans.create_or_update( GROUP_NAME, SERVER_FARM_NAME, AppServicePlan(app_service_plan_name=SERVER_FARM_NAME, location=WEST_US, sku=SkuDescription(name='S1', capacity=1, tier='Standard'))) service_plan = service_plan_async_operation.result() print_item(service_plan) # # Create a Site to be hosted on the App Service plan # print('Create a Site to be hosted on the App Service plan') site_async_operation = web_client.web_apps.create_or_update( GROUP_NAME, SITE_NAME, Site(location=WEST_US, server_farm_id=service_plan.id)) site = site_async_operation.result() print_item(site) # # List Sites by Resource Group # print('List Sites by Resource Group') for site in web_client.web_apps.list_by_resource_group(GROUP_NAME): print_item(site) # # Get a single Site # print('Get a single Site') site = web_client.web_apps.get(GROUP_NAME, SITE_NAME) print_item(site) print("Your site and server farm have been created. " "You can now go and visit at http://{}/".format( site.default_host_name)) input("Press enter to delete the site and server farm.") # # Delete a Site # print('Deleting the Site') web_client.web_apps.delete(GROUP_NAME, SITE_NAME) # # Delete the Resource Group # print('Deleting the resource group') delete_async_operation = resource_client.resource_groups.delete(GROUP_NAME) delete_async_operation.wait()