Skip to content

Azure App Service

Jump to bottom
jasper-zanjani edited this page Nov 23, 2020 · 5 revisions

Notes

"Web app" is the legacy name for Azure App Service. An App Service plan determines the billablecompute resources available for the App Services applications managed by it. A plan acts as a container for multiple web applications sharing the same server farm ("workers"), and for this reason Windows and Linux apps can't be mixed in the same App Service plan.

Pricing tiers:

  • Free/Shared: uses a shared infrastructure with minimal storage. No options for deploying different staged versions, routing of traffic, or backups
  • Basic: Dedicated compute for app, including avaiilability of SSL and manual scaling of app instance number.
  • Standard: Daily backups, automatic scaling of app instances, deployment slots, and user routing with Traffic Manager
  • Premium: more frequent backups, increased storage, and greater number of deployment slots and instance scaling options.

WebJobs

WebJobs is a feature of Azure App Service that enables you to run a program or script in the same instance as a web app, API app, or mobile app, at no additional cost and supported only on Windows App Services. There are two types:

  • Continuous webjobs defaults to running on all instances of the linked web app (although it can be configured to run on only one)
  • Triggered webjobs run only when triggered or on a schedule and on only a single instance of the linked web app selected by Azure.

Front Door

Azure Front Door works like Azure Load Balancer for web apps.

Tasks

List available runtimes

az webapp list-runtimes --linux

Create new Azure App Service plan

New-AzAppServicePlan -Name $n -ResourceGroupName $g -Location $l -Tier "Basic" -NumberofWorkers 2 -WorkerSize "Small"
az appservice plan create -g $g -n $p --is-linux

Create new web app

New-AzWebApp -Name $n -Location $l -ResourceGroupName $g -AppServicePlan $p
az webapp create -n $n -g $g --plan $p

Deploy image from ACR

Sources

az webapp create --name $n --resource-group $g --plan $p --deployment-container-image-name $registry.azurecr.io/$image:latest
az webapp config appsettings set -n $n -g $g --settings "WEBSITES_PORT=8000"

# Service principal ID
$p = az webapp identity assign -n $n -g $g --query principalId -o tsv
$s = az account show --query id --output tsv

# Grant web app permission to access the container registry
az role assignment create --assignee $p --scope /subscriptions/$s/resourceGroups/$g/provides/Microsoft.ContainerRegistry/registries/$registry

# Deploy image (note that `$registry` is specified twice in this command)
az webapp config container set -n $n -g $g --docker-custom-image-name $registry.azurecr.io/$image:latest --docker-registry-server-url https://$registry.azurecr.io

# Restart web app after making changes
az webapp restart -n $n -g $g

Deploy from GitHub

#!/bin/bash

# Replace the following URL with a public GitHub repo URL
gitrepo=https://github.com/Azure-Samples/php-docs-hello-world
webappname=mywebapp$RANDOM

# Create a resource group.
az group create --location westeurope --name myResourceGroup

# Create an App Service plan in `FREE` tier.
az appservice plan create --name $webappname --resource-group myResourceGroup --sku FREE

# Create a web app.
az webapp create --name $webappname --resource-group myResourceGroup --plan $webappname

# Deploy code from a public GitHub repository. 
az webapp deployment source config --name $webappname --resource-group myResourceGroup \
--repo-url $gitrepo --branch master --manual-integration

# Copy the result of the following command into a browser to see the web app.
echo http://$webappname.azurewebsites.net
$gitrepo="<replace-with-URL-of-your-own-GitHub-repo>"
$gittoken="<replace-with-a-GitHub-access-token>"
$webappname="mywebapp$(Get-Random)"
$location="West Europe"

# Create a resource group.
New-AzResourceGroup -Name myResourceGroup -Location $location

# Create an App Service plan in Free tier.
New-AzAppServicePlan -Name $webappname -Location $location `
-ResourceGroupName myResourceGroup -Tier Free

# Create a web app.
New-AzWebApp -Name $webappname -Location $location -AppServicePlan $webappname `
-ResourceGroupName myResourceGroup

# SET GitHub
$PropertiesObject = @{
    token = $gittoken;
}
Set-AzResource -PropertyObject $PropertiesObject `
-ResourceId /providers/Microsoft.Web/sourcecontrols/GitHub -ApiVersion 2015-08-01 -Force

# Configure GitHub deployment from your GitHub repo and deploy once.
$PropertiesObject = @{
    repoUrl = "$gitrepo";
    branch = "master";
}
Set-AzResource -PropertyObject $PropertiesObject -ResourceGroupName myResourceGroup `
-ResourceType Microsoft.Web/sites/sourcecontrols -ResourceName $webappname/web `
-ApiVersion 2015-08-01 -Force

Create Front Door

Add the front-door extension if using Azure CLI

az extension add --name front-door

Create web apps in two different regions.

$webapp1 = New-AzWebApp -Name "WebAppContoso-$(Get-Random)" -Location centralus -ResourceGroupName myResourceGroupFD -AppServicePlan myAppServicePlanCentralUS
$webapp2 = New-AzWebApp -Name "WebAppContoso-$(Get-Random)" -Location southcentralus -ResourceGroupName myResourceGroupFD -AppServicePlan myAppServicePlanSouthCentralUS
az appservice plan create --name myAppServicePlanCentralUS --resource-group myRGFDCentral
az webapp create --name WebAppContoso1 --resource-group myRGFDCentral --plan myAppServicePlanCentralUS 

az appservice plan create --name myAppServicePlanSouthCentralUS -resource-groupg myRGFDSouthCentral
az webapp create --name WebAppContoso2 --resource-group myRGFDSouthCentral --plan myAppServicePlanSouthCentralUS

Create a frontend object 

# Create a unique name
$fdname = "contoso-frontend-$(Get-Random)"

#Create the frontend object
$FrontendEndObject = New-AzFrontDoorFrontendEndpointObject `
-Name "frontendEndpoint1" `
-HostName $fdname".azurefd.net"

Create the backend pool 

# Create backend objects that points to the hostname of the web apps
$backendObject1 = New-AzFrontDoorBackendObject `
-Address $webapp1.DefaultHostName
$backendObject2 = New-AzFrontDoorBackendObject `
-Address $webapp2.DefaultHostName

# Create a health probe object
$HealthProbeObject = New-AzFrontDoorHealthProbeSettingObject `
-Name "HealthProbeSetting"

# Create the load balancing setting object
$LoadBalancingSettingObject = New-AzFrontDoorLoadBalancingSettingObject `
-Name "Loadbalancingsetting" `
-SampleSize "4" `
-SuccessfulSamplesRequired "2" `
-AdditionalLatencyInMilliseconds "0"

# Create a backend pool using the backend objects, health probe, and load balancing settings
$BackendPoolObject = New-AzFrontDoorBackendPoolObject `
-Name "myBackendPool" `
-FrontDoorName $fdname `
-ResourceGroupName myResourceGroupFD `
-Backend $backendObject1,$backendObject2 `
-HealthProbeSettingsName "HealthProbeSetting" `
-LoadBalancingSettingsName "Loadbalancingsetting"

New-AzFrontDoor `
-Name $fdname `
-ResourceGroupName myResourceGroupFD `
-RoutingRule $RoutingRuleObject `
-BackendPool $BackendPoolObject `
-FrontendEndpoint $FrontendEndObject `
-LoadBalancingSetting $LoadBalancingSettingObject `
-HealthProbeSetting $HealthProbeObject
az network front-door create \
--resource-group myRGFDCentral \
--name contoso-frontend \
--accepted-protocols http https \
--backend-address webappcontoso1.azurewebsites.net webappcontoso2.azurewebsites.net

Sources

Exam objectives quick reference guide

Exams

Topics

Clone this wiki locally