Deploy Python to Azure Functions

This tutorial walks you through using Visual Studio Code to create a serverless HTTP endpoint with Python using the Azure Functions extension. Microsoft Azure Functions runs your code in a serverless environment without needing to provision a virtual machine or publish a web app. The Azure Functions extension for VS Code greatly simplifies the process of using Functions by automatically handling many configuration concerns.

If you encounter any problems in the course of this tutorial, feel free to file an issue in the Visual Studio Code documentation repository.

Prerequisites

Details for each of these are in the sections that follow:

Azure subscription

If you don't have an Azure subscription, sign up now for a free 30-day account with $200 in Azure credits to try out any combination of services.

Visual Studio Code, Python, and the Azure Functions extension

Install the following software:

Azure Functions Core Tools

Follow the instructions for your operating system on Work with Azure Functions Core Tools in the Azure documentation. (The tools themselves are written in .NET Core, and the Core Tools package is best installed using the Node.js package manager, npm, which is why you need to install .NET Core and Node.js at present, even for Python code. Fortunately, you need install these components only once, after which VS Code automatically prompts you to install any updates.)

Sign in to Azure

Once the Functions extension is installed, sign into your Azure account by navigating to the Azure: Functions explorer, select Sign in to Azure, and follow the prompts.

Sign in to Azure through VS Code

After signing in, verify that you see the email account of your Azure subscription in the Status Bar:

VS Code status bar showing Azure account

The name you've assigned to your subscription also appears in the Azure: Functions explorer ("Primary" in the image below):

VS Code Azure App Service explorer showing subscriptions

Note: If you see the error "Cannot find subscription with name [subscription ID]", this may be because you are behind a proxy and unable to reach the Azure API. Configure HTTP_PROXY and HTTPS_PROXY environment variables with your proxy information in your terminal:

# macOS/Linux
export HTTPS_PROXY=https://username:password@proxy:8080
export HTTP_PROXY=http://username:password@proxy:8080

#Windows
set HTTPS_PROXY=https://username:password@proxy:8080
set HTTP_PROXY=http://username:password@proxy:8080

Verify prerequisites

To verify that all the Azure Functions tools are installed, select the Terminal: Create New Integrated Terminal command from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)), then run the command func:

Checking Azure Functions core tools prerequisites

The output that starts with the Azure Functions logo (you need to scroll the output upwards) indicates that the Azure Functions Core Tools are present.

Create the Function

  1. Code for Azure Functions is managed within a Function "project," which you create first before creating the code. In Azure: Functions explorer (opened using the Azure icon on the left side), select the New Project command icon, or open the Command Palette and select Azure Functions: Create New Project.

    Create new project button in the Functions explorer

  2. In the prompts that follow:

    • Specify a folder for the project. (The default is the current folder open in VS Code and you may want to create a subfolder separately.)
    • Select Python for the language.
    • Select HTTP trigger for the template. A function that uses an HTTP trigger is run whenever there's an HTTP request made to the function's endpoint. (You can see that there are a variety of other triggers for Azure Functions. To learn more, see What can I do with Functions? in the Azure documentation.)
    • Name your function "HttpExample" (rather than accepting the default "HTTPTrigger") to distinguish the function itself from the trigger. This name is used for a subfolder that contains the function's code along with configuration data, and also defines the name of the HTTP endpoint.
    • Select Anonymous for the authorization level, which makes the function publicly accessible to anyone.
    • If prompted with "Select how you would like to open your project," select Open in current window.
  3. After a short time, you see a message that the new project was created. In the Explorer, you see the subfolder created for the function, and VS Code opens the __init__.py file that contains the default function code:

    Result of creating a new Python functions project

    Note If VS Code tells you that you don't have a Python interpreter selected when it opens __init__.py, use the Python: Select Interpreter command from the Command Palette and select the virtual environment in the local .env folder (which was created as part of the project).

    Selecting the virtual environment created with the project

Tip: Whenever you want to create another function in the same project, use the Create Function command in the Azure: Functions explorer, or use the Azure Functions: Create Function command from the Command Palette (⇧⌘P (Windows, Linux Ctrl+Shift+P)). Both commands prompt you for a function name (which is the name of the endpoint), then creates a subfolder with the default files.

New Function command in the Azure: Functions explorer

Examine the code files

In the newly created function subfolder, you see three files: __init__.py contains the function's code, function.json describes the function to Azure Functions, and sample.dat is a sample data file. You can delete sample.dat if you want, as it exists only to show that you can add other files to the subfolder.

Let's look at function.json first, then the code in __init__.py.

function.json

The function.json file provides the necessary configuration information for the Azure Functions endpoint:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}

You can see that scriptFile identifies the startup file for the code, which must contain a Python function named main. You can factor your code into multiple files so long as the file specified here contains a main function.

The bindings element contains two objects, one to describe incoming requests, and the other to describe the HTTP response. For incoming requests ("direction": "in"), the function responds to HTTP GET or POST requests and doesn't require authentication. The response ("direction": "out") is an HTTP response that returns whatever value is returned from the main Python function.

__init.py__

When you create a new function, Azure Functions provides default Python code in __init__.py:

import logging

import azure.functions as func


def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        return func.HttpResponse(f"Hello {name}!")
    else:
        return func.HttpResponse(
             "Please pass a name on the query string or in the request body",
             status_code=400
        )

The important parts of the code are as follows:

  • You must import func from azure.functions; importing the logging module is optional but recommended.
  • The required main Python function receives a func.request object named req, and returns a value of type func.HttpResponse. You can learn more about the capabilities of these objects in the func.HttpRequest and func.HttpResponse references.
  • The body of main then processes the request and generates a response. In this case, the code looks for a name parameter in the URL. Failing that, it checks if the request body contains JSON (using func.HttpRequest.get_json) and that the JSON contains a name value (using the get method of the JSON object returned by get_json).
  • If a name is found, the code returns the string "Hello" with the name appended; otherwise it returns an error message.

Test and debug locally

  1. When you create the Functions project, the VS Code extension also creates a launch configuration in .vscode/launch.json that contains a single configuration named Attach to Python Functions. This configuration means you can just press F5 or use the Debug explorer to start the project:

    Debug explorer showing the Functions launch configuration

  2. When you start the debugger, a terminal opens showing output from Azure Functions, including a summary of the available endpoints (your URL might be different if you used a name other than "HttpExample"):

    Hosting environment: Production
    Content root path: d:\Examples\Python\AzureFunctions
    Now listening on: http://0.0.0.0:7071
    Application started. Press Ctrl+C to shut down.
    
    Http Functions:
    
            HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
    
  3. Use Ctrl+click (Cmd+click on macOS) on the URL in the VS Code Output window to open a browser to that address, or start a browser and paste in the same URL. In either case, you can see that the endpoint is api/<function_name>, in this case api/HttpExample. However, because that URL doesn't include a name parameter, the browser window should just show, "Please pass a name on the query string or in the request body" as appropriate for that path in the code.

  4. Now try adding a name parameter to the use, such as http://localhost:7071/api/HttpExample?name=VS%20Code, and in the browser window you should see the message, "Hello VS Code!", demonstrating that you've run that code path.

  5. To pass the name value in a JSON request body, you can use a tool like curl with the JSON inline:

    # Mac OS/Linux: modify the URL if you're using a different function name
    curl --header "Content-Type: application/json" --request POST \
        --data {"name":"VS Code"} http://localhost:7071/api/HttpExample
    
    # Windows (escaping on the quotes is necessary; also modify the URL
    # if you're using a different function name)
    curl --header "Content-Type: application/json" --request POST \
        --data {"""name""":"""VS Code"""} http://localhost:7071/api/HttpExample
    

    Alternately, create a file like data.json that contains {"name":"VS Code"} and use the command curl --header "Content-Type: application/json" --request POST --data @data.json http://localhost:7071/api/HttpExample.

  6. To test debugging the function, set a breakpoint on the line that reads name = req.params.get('name') and make a request to the URL again. The VS Code debugger should stop on that line, allowing you to examine variables and step through the code. (For a short walkthrough of basic debugging, see Tutorial - Configure and run the debugger.)

  7. When you're satisfied that you've thoroughly tested the function locally, stop the debugger (with the Debug > Stop Debugging menu command or the Disconnect command on the debugging toolbar).

Deploy to Azure Functions

In these steps, you use the Functions extension to create a "Function App" on Azure. A Function App is composed of a storage account for data, an App Service Plan (which corresponds to the Linux virtual machine on which the App Service runs), and an App Service (the hosting service for your endpoints that runs on the virtual machine). All of these resources are organized within a single resource group.

  1. In the Azure: Functions explorer, select the Deploy to Function App command, or use the Azure Functions: Deploy to Function App command on the Command Palette. A "Function App" here is again the Azure resource that hosts your code.

    Deploy to Function App command

  2. When prompted, select Create New Function App in Azure, and provide a name that's unique across Azure (typically using your personal or company name along with other unique identifiers; you can use letters, numbers, and hyphens). If you previously created a Function App, its name appears in this list of options.

  3. The extension performs the following actions, which you can observe in VS Code popup messages and the Output window (the process takes a few minutes):

    • Create a resource group using the name you gave (removing hyphens).
    • In that resource group, create the storage account, App Service Plan, and App Service to host your code.
    • Deploy your code to the Function app.

    You can also see progress in the Azure: Functions explorer:

    Deployment progress indicator in the Azure: Functions explorer

  4. Once deployment is complete, the Output window shows the public endpoint on Azure:

    HTTP Trigger Urls:
      HttpExample: https://vscode-azure-functions.azurewebsites.net/api/HttpExample
    
  5. Use this endpoint to run the same tests you did locally, using URL parameters and/or requests with JSON data in the request body. You should see the same results from the public endpoint as you did locally.

Add a second Function

After your first deployment, you can make changes to your code, such as adding additional functions, and redeploy to the same Functions App.

  1. In the Azure: Functions explorer, select the Create Function command or use Azure Functions: Create Function from the Command Palette. Specify the following details for the function:

    • Template: HTTP trigger
    • Name: "DigitsOfPi"
    • Authorization level: Anonymous
  2. In the VS Code file explorer, you should see a subfolder for your function name that again contains files named __init__.py, function.json, and sample.dat.

  3. Replace the code in __init__.py to match the following, which generates a string containing the value of PI to a number of digits specified in the URL (this code uses only a URL parameter)

    import logging
    
    import azure.functions as func
    
    """ Adapted from the second, shorter solution at http://www.codecodex.com/wiki/Calculate_digits_of_pi#Python
    """
    
    def pi_digits_Python(digits):
        scale = 10000
        maxarr = int((digits / 4) * 14)
        arrinit = 2000
        carry = 0
        arr = [arrinit] * (maxarr + 1)
        output = ""
    
        for i in range(maxarr, 1, -14):
            total = 0
            for j in range(i, 0, -1):
                total = (total * j) + (scale * arr[j])
                arr[j] = total % ((j * 2) - 1)
                total = total / ((j * 2) - 1)
    
            output += "%04d" % (carry + (total / scale))
            carry = total % scale
    
        return output;
    
    def main(req: func.HttpRequest) -> func.HttpResponse:
        logging.info('DigitsOfPi HTTP trigger function processed a request.')
    
        digits_param = req.params.get('digits')
    
        if digits_param is not None:
            try:
                digits = int(digits_param)
            except ValueError:
                digits = 10   # A default
    
            if digits > 0:
                digit_string = pi_digits_Python(digits)
    
                # Insert a decimal point in the return value
                return func.HttpResponse(digit_string[:1] + '.' + digit_string[1:])
    
        return func.HttpResponse(
             "Please pass the URL parameter ?digits= to specify a positive number of digits.",
             status_code=400
        )
    
  4. Because the code supports only HTTP GET, modify function.json so that the "methods" collection contains only "get" (that is, remove "post"). The whole file should appear as follows:

    {
      "scriptFile": "__init__.py",
      "bindings": [
        {
          "authLevel": "anonymous",
          "type": "httpTrigger",
          "direction": "in",
          "name": "req",
          "methods": [
            "get"
          ]
        },
        {
          "type": "http",
          "direction": "out",
          "name": "$return"
        }
      ]
    }
    
  5. Start the debugger by pressing F5 or selecting the Debug > Start Debugging menu command. The Output window should now show both endpoints in your project:

    Http Functions:
    
            DigitsOfPi: [GET] http://localhost:7071/api/DigitsOfPi
    
            HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
    
  6. In a browser, or from curl, make a request to http://localhost:7071/api/DigitsOfPi?digits=125 and observe the output. (You might notice that the code algorithm isn't entirely accurate, but we'll leave the improvements to you!) Stop the debugger when you're finished.

  7. Redeploy the code by using the Deploy to Function App in the Azure: Functions explorer. If prompted, select the Function App created previously.

  8. Once deployment finishes (it takes a few minutes!), the Output window shows the public endpoints with which you can repeat your tests.

Clean up resources

The Function App you created includes resources that can incur minimal costs (refer to Functions Pricing). To clean up the resources, right-click the Function App in the Azure: Functions explorer and select Delete Function App. You can also visit the Azure portal, select Resource groups from the left-side navigation pane, select the resource group that was created in the process of this tutorial, and then use the Delete resource group command.

Next steps

Congratulations on completing this walkthrough of deploying Python code to Azure Functions! You're now ready to create many more serverless functions.

As noted earlier, you can learn more about the Functions extension by visiting its GitHub repository, vscode-azurefunctions. Issues and contributions are also welcome.

To learn more about Azure Functions, browse the Azure Functions documentation, and especially explore the different triggers you can use.

To learn more about Azure services that you can use from Python, including data storage along with AI and Machine Learning services, visit Azure Python Developer Center.

There are also other Azure extensions for VS Code that you may find helpful. Just search on "Azure" in the Extensions explorer:

Azure extensions for VS Code

Some popular extensions are:

And again, if you encountered any problems in the course of this tutorial, feel free to file an issue in the VS Code docs repo.