Quickstart: Deploy a Python (Django or Flask) web app to Azure App Service

Article
07/26/2023

Note

Beginning June 1, 2024, all newly created App Service apps will have the option to create a unique default hostname with a naming convention of <app-name>-<random-hash>.<region>.azurewebsites.net. The names of existing apps will not change.

Example: myapp-ds27dh7271aah175.westus-01.azurewebsites.net

For more information, refer to Unique Default Hostname for App Service Resource.

In this quickstart, you'll deploy a Python web app (Django or Flask) to Azure App Service. Azure App Service is a fully managed web hosting service that supports Python apps hosted in a Linux server environment.

To complete this quickstart, you need:

An Azure account with an active subscription. Create an account for free.
Python 3.9 or higher installed locally.

Note

This article contains current instructions on deploying a Python web app using Azure App Service. Python on Windows is no longer supported.

1 - Sample application

This quickstart can be completed using either Flask or Django. A sample application in each framework is provided to help you follow along with this quickstart. Download or clone the sample application to your local workstation.

Flask
Django

git clone https://github.com/Azure-Samples/msdocs-python-flask-webapp-quickstart

git clone https://github.com/Azure-Samples/msdocs-python-django-webapp-quickstart

To run the application locally:

Flask
Django

Go to the application folder:

cd msdocs-python-flask-webapp-quickstart

Create a virtual environment for the app:

Windows
macOS/Linux

py -m venv .venv
.venv\scripts\activate

python3 -m venv .venv
source .venv/bin/activate

Install the dependencies:
```
pip install -r requirements.txt
```
Run the app:
```
flask run
```
Browse to the sample application at http://localhost:5000 in a web browser.

Having issues? Let us know.

Go to the application folder:

cd msdocs-python-django-webapp-quickstart

Create a virtual environment for the app:

Windows
macOS/Linux

py -m venv .venv
.venv\scripts\activate

python3 -m venv .venv
source .venv/bin/activate

Install the dependencies:
```
pip install -r requirements.txt
```
Run the app:
```
python manage.py runserver
```
Browse to the sample application at http://localhost:8000 in a web browser.

Having issues? Let us know.

2 - Create a web app in Azure

To host your application in Azure, you need to create Azure App Service web app in Azure. You can create a web app using the Azure CLI, VS Code, Azure Tools extension pack, or Azure portal.

Azure CLI commands can be run on a computer with the Azure CLI installed.

Azure CLI has a command az webapp up that will create the necessary resources and deploy your application in a single step.

If necessary, login to Azure using az login.

az login

Create the webapp and other resources, then deploy your code to Azure using az webapp up.

az webapp up --runtime PYTHON:3.9 --sku B1 --logs

The --runtime parameter specifies what version of Python your app is running. This example uses Python 3.9. To list all available runtimes, use the command az webapp list-runtimes --os linux --output table.
The --sku parameter defines the size (CPU, memory) and cost of the app service plan. This example uses the B1 (Basic) service plan, which will incur a small cost in your Azure subscription. For a full list of App Service plans, view the App Service pricing page.
The --logs flag configures default logging required to enable viewing the log stream immediately after launching the webapp.
You can optionally specify a name with the argument --name <app-name>. If you don't provide one, then a name will be automatically generated.
You can optionally include the argument --location <location-name> where <location_name> is an available Azure region. You can retrieve a list of allowable regions for your Azure account by running the az account list-locations command.

The command may take a few minutes to complete. While the command is running, it provides messages about creating the resource group, the App Service plan, and the app resource, configuring logging, and doing ZIP deployment. It then gives the message, "You can launch the app at http://<app-name>.azurewebsites.net", which is the app's URL on Azure.

The webapp '<app-name>' doesn't exist
Creating Resource group '<group-name>' ...
Resource group creation complete
Creating AppServicePlan '<app-service-plan-name>' ...
Creating webapp '<app-name>' ...
Configuring default logging for the app, if not already enabled
Creating zip with contents of dir /home/cephas/myExpressApp ...
Getting scm site credentials for zip deployment
Starting zip deployment. This operation can take a while to complete ...
Deployment endpoint responded with status code 202
You can launch the app at http://<app-name>.azurewebsites.net
{
  "URL": "http://<app-name>.azurewebsites.net",
  "appserviceplan": "<app-service-plan-name>",
  "location": "centralus",
  "name": "<app-name>",
  "os": "<os-type>",
  "resourcegroup": "<group-name>",
  "runtime_version": "python|3.9",
  "runtime_version_detected": "0.0",
  "sku": "FREE",
  "src_path": "<your-folder-location>"
}

Note

The az webapp up command does the following actions:

Create a default resource group.
Create a default App Service plan.
Create an app with the specified name.
Zip deploy all files from the current working directory, with build automation enabled.
Cache the parameters locally in the .azure/config file so that you don't need to specify them again when deploying later with az webapp up or other az webapp commands from the project folder. The cached values are used automatically by default.

To create Azure resources in VS Code, you must have the Azure Tools extension pack installed and be signed into Azure from VS Code.

Download Azure Tools extension pack

In the application folder, open VS Code:

code .

Instructions	Screenshot
Locate the Azure icon in the left-hand toolbar. Select it to bring up the Azure Tools for VS Code extension. If you do not see the Azure Tools icon, make sure you have the Azure Tools extension for VS Code installed.
In the Azure Tools extension for VS Code: Find the RESOURCES section and select your subscription. Select + (Create Resource...)
Choose the Create App Service Web App... option.
Enter the name msdocs-python-webapp-quickstart-XYZ for this web app, where XYZ is any three unique characters. When deployed, this name is used as your app name in the form `https://<app-name>.azurewebsites.net`.
Select the runtime stack for the application. In this example, select Python 3.9.
Select the App Service plan (pricing tier) for this web app. The App Service plan controls how many resources (CPU/memory) are available to your app and how much you pay. For this example, select the Basic (B1) pricing tier. This plan will incur a small charge against your Azure subscription but is recommended for better performance over the Free (F1) tier.
Select the Deploy button in the "Created new web app" notification.
Select the quickstart folder you are working in as the one to deploy.
Answer Yes to update your build configuration and improve deployment performance.
When the deployment is complete, a notification will appear in the lower right corner of VS Code. You can use this notification to browse to your web app.

Instructions	Screenshot
In the Azure portal: Enter app services in the search bar at the top of the Azure portal. Select the item labeled App Services under the under Services heading on the menu that appears below the search bar.
On the App Services page, select + Create, then select + Web App from the drop-down menu.
On the Create Web App page, fill out the form as follows. Resource Group → Select Create new and use a name of msdocs-python-webapp-quickstart. Name → msdocs-python-webapp-quickstart-XYZ where XYZ is any three random characters. This name must be unique across Azure. Runtime stack → Python 3.9. Region → Any Azure region near you. App Service Plan → Under Pricing plan, select Explore pricing plans to select a different App Service plan.
The App Service plan controls how many resources (CPU/memory) are available to your app and the cost of those resources. For this example, under Dev/Test, select the Basic B1 plan. The Basic B1 plan will incur a small charge against your Azure account but is recommended for better performance over the Free F1 plan. When finished, select Select to apply your changes.
On the main Create Web App page, select the Review + create at the bottom of the screen. This will take you to the Review page. Select Create to create your App Service.

Having issues? Let us know.

3 - Deploy your application code to Azure

Azure App service supports multiple methods to deploy your application code to Azure including support for GitHub Actions and all major CI/CD tools. This article focuses on how to deploy your code from your local workstation to Azure.

Since the az webapp up command created the necessary resources and deployed your application in a single step, you can move on to 4 - Browse to the app.

You can deploy your application code from a local Git repository to Azure by configuring a Git remote in your local repo pointing at Azure to push code to. The URL of the remote repository and Git credentials needed for configuration can be retrieved using either the Azure portal or the Azure CLI.

Azure portal
Azure CLI

Instructions	Screenshot
Navigate to the App Service for your application. Enter the name of your App Service in the search box at the top of the screen. Under the Resources heading, select the App Service to navigate to it.
On the page for the App Service: Select Deployment Center from the menu on the left side of the screen. Select Local Git in the dropdown list labeled Source. Select Save.
After saving, the page will refresh and display the address for the remote Git repository. Copy the value of the Git Clone Uri as this value will be used to set up a Git remote in a later step.
On the Deployment Center page Navigate to the Local Git/FTPS credentials tab. Locate the local git username and password under the Application scope credentials. Keep this screen open so you can copy these credentials momentarily when you deploy your code to the remote repository. Be sure to copy the local git username, which starts with a `$`, for example `$msdocs-python-webapp-quickstart-123`. When you push code to the remote Git repository for the first time, these credentials are needed to authenticate to the remote repository.

Next, in the root directory of your application, configure a Git remote that points to Azure using the Git URL of the Azure remote obtained in a previous step.

git remote add azure <git-deployment-url>

You can now push code from your local Git repository to Azure using the Git remote you just configured. The default deployment branch for App Service is master, but many Git repositories are moving away from master to main. You can either specify the mapping from local branch name to remote branch name in the push (as shown below), or you can configure your DEPLOYMENT_BRANCH app setting.

git push azure main:master

The first time you push code to Azure, Git will prompt you for the Azure deployment credentials you obtained in the previous step. Git will then cache these credentials so you won't have to reenter them on subsequent deployments.

First, configure the deployment source for your web app to be local Git using the az webapp deployment source command. This command will output the URL of the remote Git repository that you will be pushing code to. Make a copy of this value as you will need it in a later step.

bash
PowerShell terminal

# Change these values to the ones used to create the App Service.
RESOURCE_GROUP_NAME='msdocs-python-webapp-quickstart'
APP_SERVICE_NAME='msdocs-python-webapp-quickstart-123'

az webapp deployment source config-local-git \
    --name $APP_SERVICE_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --output tsv

# Change these values to the ones used to create the App Service.
$RESOURCE_GROUP_NAME='msdocs-python-webapp-quickstart'
$APP_SERVICE_NAME='msdocs-python-webapp-quickstart-123'

az webapp deployment source config-local-git `
    --name $APP_SERVICE_NAME `
    --resource-group $RESOURCE_GROUP_NAME `
    --output tsv

Retrieve the deployment credentials for your application. These will be needed for Git to authenticate to Azure when you push code to Azure in a later step.

bash
PowerShell terminal

az webapp deployment list-publishing-credentials \
    --name $APP_SERVICE_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --query "{Username:publishingUserName, Password:publishingPassword}" \
    --output table

az webapp deployment list-publishing-credentials `
    --name $APP_SERVICE_NAME `
    --resource-group $RESOURCE_GROUP_NAME `
    --query "{Username:publishingUserName, Password:publishingPassword}" `
    --output table

Next, in the root directory of your application, configure a Git remote that points to Azure using the Git URL of the Azure remote obtained in a previous step.

git remote add azure <git-deployment-url>

git push azure main:master

The first time you push code to Azure, Git will prompt you for the Azure deployment credentials you obtained in a previous step. Git will then cache these credentials so you won't have to reenter them on subsequent deployments.

Applications can be deployed to Azure by creating and uploading a ZIP file of the application code to Azure. ZIP files can be uploaded to Azure using the Azure CLI or an HTTP client like cURL.

Enable build automation

When deploying a ZIP file of your Python code, you need to set a flag to enable Azure build automation. The build automation will install any necessary requirements and package the application to run on Azure.

Build automation in Azure is enabled by setting the SCM_DO_BUILD_DURING_DEPLOYMENT app setting in either the Azure portal or Azure CLI.

Azure portal
Azure CLI

Instructions	Screenshot
On the page for the web app in the Azure portal: Select Configuration under the Settings header in the left toolbar to bring up the Application settings. Under Application settings, select New application setting.
Using the dialog, enter a new setting with: Name → SCM_DO_BUILD_DURING_DEPLOYMENT Value → true
Select the Save to save your settings.

Use the az webapp config appsettings set command to set the SCM_DO_BUILD_DURING_DEPLOYMENT setting to a value of true.

bash
PowerShell terminal

# Change these values to the ones used to create the App Service.
RESOURCE_GROUP_NAME='msdocs-python-webapp-quickstart'
APP_SERVICE_NAME='msdocs-python-webapp-quickstart-123'

az webapp config appsettings set \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $APP_SERVICE_NAME \
    --settings SCM_DO_BUILD_DURING_DEPLOYMENT=true

# Change these values to the ones used to create the App Service.
$resourceGroupName='msdocs-python-webapp-quickstart'
$appServiceName='msdocs-python-webapp-quickstart-123'

az webapp config appsettings set `
    --resource-group $resourceGroupName `
    --name $appServiceName `
    --settings SCM_DO_BUILD_DURING_DEPLOYMENT=true

Create a ZIP file of your application

Next, create a ZIP file of your application. You only need to include components of the application itself. You do not need to include any files or directories that start with a dot (.) such as .venv, .gitignore, .github, or .vscode.

Windows
macOS/Linux

On Windows, use a program like 7-Zip to create a ZIP file needed to deploy the application.

On macOS or Linux, you can use the built-in zip utility to create a ZIP file.

zip -r <file-name>.zip . -x '.??*'

Upload the ZIP file to Azure

Once you have a ZIP file, the file can be uploaded to Azure using either Azure CLI or an HTTP client like Postman or cURL.

The az webapp deploy command can be used to upload and deploy a zip file to Azure.

bash
PowerShell terminal

# Change these values to the ones used to create the App Service.
RESOURCE_GROUP_NAME='msdocs-python-webapp-quickstart'
APP_SERVICE_NAME='msdocs-python-webapp-quickstart-123'

az webapp deploy \
    --name $APP_SERVICE_NAME \
    --resource-group $RESOURCE_GROUP_NAME \
    --src-path <zip-file-path>

# Change these values to the ones used to create the App Service.
$resourceGroupName='msdocs-python-webapp-quickstart'
$appServiceName='msdocs-python-webapp-quickstart-123'

az webapp deploy `
    --name $appServiceName `
    --resource-group $resourceGroupName `
    --src-path <zip-file-path>

To use Postman to upload your ZIP file to Azure, you will need the deployment username and password for your App Service. These credentials can be obtained from the Azure portal.

On the page for the web app, select Deployment center from the menu on the left side of the page.
Select the FTPS credentials tab.
The Username and Password are shown under the Application scope heading. For zip file deployments, only use the part of the username after the \ character that starts with a $, for example $msdocs-python-webapp-quickstart-123. These credentials will be needed when uploading your zip file with Postman.

In Postman, upload your file using the following steps.

Instructions	Screenshot
Click on the plus (+) sign icon to create a new request. Select POST for the request type. Enter the url `https://\<app-name\>.scm.azurewebsites.net/api/zipdeploy` where <app-name> is the name of the web app. This URL is the endpoint used to deploy a ZIP file to your Azure service.
In the Authorization tab: Set the Type to Basic. Enter the deployment username and password obtained from the Azure portal above. Be sure to only use the portion of the username after the `\` character that starts with a `$`.
In the Body tab: Select binary as the content type. Use the Select File button to select your zip file.
The filename of the file to be uploaded will be shown in the Body section. Select the Send button to upload your zip file to Azure. Depending on your network bandwidth, files usually take between 10 and 30 seconds to upload to Azure.

To use cURL to upload your ZIP file to Azure, you will need the deployment username and password for your App Service. These credentials can be obtained from the Azure portal.

On the page for the web app, select Deployment center from the menu on the left side of the page.
Select the FTPS credentials tab.
The Username and Password are shown under the Application scope heading. For zip file deployments, only use the part of the username after the \ character that starts with a $, for example $msdocs-python-webapp-quickstart-123. These credentials will be needed in the cURL command.

Run the following curl command to upload your zip file to Azure and deploy your application. The username is the deployment username obtained in step 3. When this command is run, you will be prompted for the deployment password.

bash
PowerShell terminal

curl -X POST \
    -H 'Content-Type: application/zip' \
    -u '<deployment-user>' \
    -T <zip-file-name> \
    https://<app-name>.scm.azurewebsites.net/api/zipdeploy

For PowerShell, make sure to enclose the username in single quotes so PowerShell does not try to interpret the username as a PowerShell variable.

curl -X POST `
    -H 'Content-Type: application/zip' `
    -u '<deployment-user>' `
    -T <zip-file-name> `
    https://<app-name>.scm.azurewebsites.net/api/zipdeploy

Depending on your network bandwidth, files usually take between 10 and 30 seconds to upload to Azure.

Having issues? Refer first to the Troubleshooting guide, otherwise, let us know.

4 - Browse to the app

Browse to the deployed application in your web browser at the URL http://<app-name>.azurewebsites.net. If you see a default app page, wait a minute and refresh the browser.

The Python sample code is running a Linux container in App Service using a built-in image.

Screenshot of the app running in Azure

Congratulations! You've deployed your Python app to App Service.

Having issues? Refer first to the Troubleshooting guide, otherwise, let us know.

5 - Stream logs

Azure App Service captures all messages output to the console to assist you in diagnosing issues with your application. The sample apps include print() statements to demonstrate this capability.

Flask
Django

@app.route('/')
def index():
   print('Request for index page received')
   return render_template('index.html')

@app.route('/favicon.ico')
def favicon():
    return send_from_directory(os.path.join(app.root_path, 'static'),
                               'favicon.ico', mimetype='image/vnd.microsoft.icon')

@app.route('/hello', methods=['POST'])
def hello():
   name = request.form.get('name')

   if name:
       print('Request for hello page received with name=%s' % name)
       return render_template('hello.html', name = name)
   else:
       print('Request for hello page received with no name or blank name -- redirecting')
       return redirect(url_for('index'))

def index(request):
    print('Request for index page received')
    return render(request, 'hello_azure/index.html')

@csrf_exempt
def hello(request):
    if request.method == 'POST':
        name = request.POST.get('name')
        
        if name is None or name == '':
            print("Request for hello page received with no name or blank name -- redirecting")
            return redirect('index')
        else:
            print("Request for hello page received with name=%s" % name)
            context = {'name': name }
            return render(request, 'hello_azure/hello.html', context)
    else:

The contents of the App Service diagnostic logs can be reviewed using the Azure CLI, VS Code, or Azure portal.

First, you need to configure Azure App Service to output logs to the App Service filesystem using the az webapp log config command.

bash
PowerShell terminal

az webapp log config \
    --web-server-logging filesystem \
    --name $APP_SERVICE_NAME \
    --resource-group $RESOURCE_GROUP_NAME

az webapp log config `
    --web-server-logging 'filesystem' `
    --name $APP_SERVICE_NAME `
    --resource-group $RESOURCE_GROUP_NAME

To stream logs, use the az webapp log tail command.

bash
PowerShell terminal

az webapp log tail \
    --name $APP_SERVICE_NAME \
    --resource-group $RESOURCE_GROUP_NAME

az webapp log tail `
    --name $APP_SERVICE_NAME `
    --resource-group $RESOURCE_GROUP_NAME

Refresh the home page in the app or attempt other requests to generate some log messages. The output should look similar to the following.

Starting Live Log Stream ---

2021-12-23T02:15:52.740703322Z Request for index page received
2021-12-23T02:15:52.740740222Z 169.254.130.1 - - [23/Dec/2021:02:15:52 +0000] "GET / HTTP/1.1" 200 1360 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/hello" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:15:52.841043070Z 169.254.130.1 - - [23/Dec/2021:02:15:52 +0000] "GET /static/bootstrap/css/bootstrap.min.css HTTP/1.1" 200 0 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:15:52.884541951Z 169.254.130.1 - - [23/Dec/2021:02:15:52 +0000] "GET /static/images/azure-icon.svg HTTP/1.1" 200 0 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:15:53.043211176Z 169.254.130.1 - - [23/Dec/2021:02:15:53 +0000] "GET /favicon.ico HTTP/1.1" 404 232 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"

2021-12-23T02:16:01.304306845Z Request for hello page received with name=David
2021-12-23T02:16:01.304335945Z 169.254.130.1 - - [23/Dec/2021:02:16:01 +0000] "POST /hello HTTP/1.1" 200 695 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:16:01.398399251Z 169.254.130.1 - - [23/Dec/2021:02:16:01 +0000] "GET /static/bootstrap/css/bootstrap.min.css HTTP/1.1" 304 0 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/hello" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"
2021-12-23T02:16:01.430740060Z 169.254.130.1 - - [23/Dec/2021:02:16:01 +0000] "GET /static/images/azure-icon.svg HTTP/1.1" 304 0 "https://msdocs-python-webapp-quickstart-123.azurewebsites.net/hello" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0"

Instructions	Screenshot
First, you need to enable streaming logs in Azure App Service. In the App Service section of the Azure Tools for VS Code extension, right-click on your App Service instance and select Start Streaming Logs from the menu.
The console logs appear in VS Code's Output window. Refresh the home page in the app or attempt other requests to generate some log messages. You will see any log messages generated by your app as well as other messages generated by the service in the output.

Instructions	Screenshot
First, you need to enable streaming logs in Azure App Service. Navigate to page for the App Service instance in the Azure portal. Select the App Service logs under the Monitoring heading in the menu on the left side of the page. Change the Application Logging property from Off to File System. Enter a retention period of 30 days for the logs. Select Save to save your changes.
Select the Log stream item from the menu under the Monitoring section. Refresh the home page in the app or attempt other requests to generate some log messages. You will see any log messages generated by your app and messages generated by the service in the output.

Instructions

Screenshot

First, you need to enable streaming logs in Azure App Service. Navigate to page for the App Service instance in the Azure portal.

Select the App Service logs under the Monitoring heading in the menu on the left side of the page.
Change the Application Logging property from Off to File System.
Enter a retention period of 30 days for the logs.
Select Save to save your changes.

A screenshot of the location in the Azure portal where to enable streaming logs.

Select the Log stream item from the menu under the Monitoring section. Refresh the home page in the app or attempt other requests to generate some log messages.

You will see any log messages generated by your app and messages generated by the service in the output.

A screenshot of how to view logs in the Azure portal.

Having issues? Refer first to the Troubleshooting guide, otherwise, let us know.

Clean up resources

When you're finished with the sample app, you can remove all of the resources for the app from Azure. It will not incur extra charges and keep your Azure subscription uncluttered. Removing the resource group also removes all resources in the resource group and is the fastest way to remove all Azure resources for your app.

Delete the resource group by using the az group delete command.

az group delete \
    --name msdocs-python-webapp-quickstart \
    --no-wait

The --no-wait argument allows the command to return before the operation is complete.

Instructions	Screenshot
In the Azure Tools extension for VS Code: Find the RESOURCES section. Select the Group By icon and select Group by Resource Group.
In the list of resources, find the resource group to delete, right-click it, and select Delete Resource Group.... You'll be prompted to confirm the deletion by entering the name of the resource group in the dialog box.

Follow these steps while signed-in to the Azure portal to delete a resource group.

Instructions	Screenshot
Navigate to the resource group in the Azure portal. Enter the name of the resource group in the search bar at the top of the page. Under the Resource Groups heading, select the name of the resource group to navigate to it.
Select the Delete resource group button at the top of the page.
In the confirmation dialog, enter the name of the resource group to confirm deletion. Select Delete to delete the resource group.