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()