Quickstart: Create a Python Durable Functions app

3. At the prompts, provide the following information:

   Prompt	Action	Description
   Select a language for your function app project	Select Python.	Creates a local Python Functions project.
   Select a version	Select Azure Functions v4.	You see this option only when Core Tools isn't already installed. In this case, Core Tools is installed the first time you run the app.
   Python version	Select Python 3.7, Python 3.8, Python 3.9, or Python 3.10.	Visual Studio Code creates a virtual environment by using the version you select.
   Select a template for your project's first function	Select Skip for now.
   Select how you would like to open your project	Select Open in current window.	Opens Visual Studio Code in the folder you selected.

3. At the prompts, provide the following information:

   Prompt	Value	Description
   Select a language	Select Python (Programming Model V2).	Creates a local Python Functions project by using the V2 programming model.
   Select a version	Select Azure Functions v4.	You see this option only when Core Tools isn't already installed. In this case, Core Tools is installed the first time you run the app.
   Python version	Select Python 3.7, Python 3.8, Python 3.9, or Python 3.10.	Visual Studio Code creates a virtual environment by using the version you select.
   Select how you would like to open your project	Select Open in current window.	Opens Visual Studio Code in the folder you selected.

Orchestrator function

You use a template to create the Durable Functions app code in your project.

1. In the command palette, enter and then select Azure Functions: Create Function.

2. At the prompts, provide the following information:

   Prompt	Action	Description
   Select a template for your function	Select Durable Functions orchestrator.	Creates a Durable Functions app orchestration.
   Provide a function name	Select HelloOrchestrator.	A name for your durable function.

You added an orchestrator to coordinate activity functions. Open HelloOrchestrator/__init__.py to see the orchestrator function. Each call to context.call_activity invokes an activity function named Hello.

Next, you add the referenced Hello activity function.

Activity function

1. In the command palette, enter and then select Azure Functions: Create Function.

2. At the prompts, provide the following information:

   Prompt	Action	Description
   Select a template for your function	Select Durable Functions activity.	Creates an activity function.
   Provide a function name	Enter Hello.	The name of your activity function.

You added the Hello activity function that is invoked by the orchestrator. Open Hello/__init__.py to see that it takes a name as input and returns a greeting. An activity function is where you perform actions such as making a database call or performing a computation.

Finally, you add an HTTP-triggered function that starts the orchestration.

Client function (HTTP starter)

1. In the command palette, enter and then select Azure Functions: Create Function.

2. At the prompts, provide the following information:

   Prompt	Action	Description
   Select a template for your function	Select Durable Functions HTTP starter.	Creates an HTTP starter function.
   Provide a function name	Enter DurableFunctionsHttpStart.	The name of your client function
   Authorization level	Select Anonymous.	For demo purposes, this value allows the function to be called without using authentication.

You added an HTTP-triggered function that starts an orchestration. Open DurableFunctionsHttpStart/__init__.py to see that it uses client.start_new to start a new orchestration. Then it uses client.create_check_status_response to return an HTTP response containing URLs that can be used to monitor and manage the new orchestration.

You now have a Durable Functions app that can be run locally and deployed to Azure.

Requirements

Version 2 of the Python programming model requires the following minimum versions:

• Azure Functions Runtime v4.16+
• Azure Functions Core Tools v4.0.5095+ (if running locally)
• azure-functions-durable v1.2.4+

Enable the v2 programming model

The following application setting is required to run the v2 programming model:

• Name: AzureWebJobsFeatureFlags
• Value: EnableWorkerIndexing

If you're running locally by using Azure Functions Core Tools, add this setting to your local.settings.json file. If you're running in Azure, complete these steps by using a relevant tool:

az functionapp config appsettings set --name <FUNCTION_APP_NAME> --resource-group <RESOURCE_GROUP_NAME> --settings AzureWebJobsFeatureFlags=EnableWorkerIndexing

Update-AzFunctionAppSetting -Name <FUNCTION_APP_NAME> -ResourceGroupName <RESOURCE_GROUP_NAME> -AppSetting @{"AzureWebJobsFeatureFlags" = "EnableWorkerIndexing"}

To create a basic Durable Functions app by using these three function types, replace the contents of function_app.py with the following Python code:

import azure.functions as func
import azure.durable_functions as df

myApp = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)

# An HTTP-triggered function with a Durable Functions client binding
@myApp.route(route="orchestrators/{functionName}")
@myApp.durable_client_input(client_name="client")
async def http_start(req: func.HttpRequest, client):
    function_name = req.route_params.get('functionName')
    instance_id = await client.start_new(function_name)
    response = client.create_check_status_response(req, instance_id)
    return response

# Orchestrator
@myApp.orchestration_trigger(context_name="context")
def hello_orchestrator(context):
    result1 = yield context.call_activity("hello", "Seattle")
    result2 = yield context.call_activity("hello", "Tokyo")
    result3 = yield context.call_activity("hello", "London")

    return [result1, result2, result3]

# Activity
@myApp.activity_trigger(input_name="city")
def hello(city: str):
    return f"Hello {city}"

Review the following table for an explanation of each function and its purpose in the sample:

1. To test your function, set a breakpoint in the Hello activity function code (in Hello/__init__.py). Select F5 or select Debug: Start Debugging in the command palette to start the function app project. Output from Core Tools appears in the terminal panel.

   Note

   For more information about debugging, see Durable Functions diagnostics.

1. To test your function, set a breakpoint in the hello activity function code. Select F5 or select Debug: Start Debugging in the command palette to start the function app project. Output from Core Tools appears in the terminal panel.

   Note

   For more information about debugging, see Durable Functions diagnostics.

5. Use your browser or an HTTP test tool to send an HTTP POST request to the URL endpoint.

   Replace the last segment with the name of the orchestrator function (HelloOrchestrator). The URL should be similar to http://localhost:7071/api/orchestrators/HelloOrchestrator.

   The response is the HTTP function's initial result. It lets you know that the durable orchestration has started successfully. It doesn't yet display the end result of the orchestration. The response includes a few useful URLs. For now, query the status of the orchestration.

6. Copy the URL value for statusQueryGetUri, paste it in your browser's address bar, and execute the request. You can also continue to use your HTTP test tool to issue the GET request.

   The request queries the orchestration instance for the status. You should see that the instance finished and that it includes the outputs or results of the durable function. It looks similar to this example:

   {
       "name": "HelloOrchestrator",
       "instanceId": "9a528a9e926f4b46b7d3deaa134b7e8a",
       "runtimeStatus": "Completed",
       "input": null,
       "customStatus": null,
       "output": [
           "Hello Tokyo!",
           "Hello Seattle!",
           "Hello London!"
       ],
       "createdTime": "2020-03-18T21:54:49Z",
       "lastUpdatedTime": "2020-03-18T21:54:54Z"
   }
   

5. Use your browser or an HTTP test tool to send an HTTP POST request to the URL endpoint.

   Replace the last segment with the name of the orchestrator function (HelloOrchestrator). The URL should be similar to http://localhost:7071/api/orchestrators/HelloOrchestrator.

   The response is the HTTP function's initial result. It lets you know that the durable orchestration has started successfully. It doesn't yet display the end result of the orchestration. The response includes a few useful URLs. For now, query the status of the orchestration.

6. Copy the URL value for statusQueryGetUri, paste it in your browser's address bar, and execute the request. You can also continue to use your HTTP test tool to issue the GET request.

   The request queries the orchestration instance for the status. You should see that the instance finished and that it includes the outputs or results of the durable function. It looks similar to this example:

   {
       "name": "hello_orchestrator",
       "instanceId": "9a528a9e926f4b46b7d3deaa134b7e8a",
       "runtimeStatus": "Completed",
       "input": null,
       "customStatus": null,
       "output": [
           "Hello Tokyo!",
           "Hello Seattle!",
           "Hello London!"
       ],
       "createdTime": "2020-03-18T21:54:49Z",
       "lastUpdatedTime": "2020-03-18T21:54:54Z"
   }
   

1. Copy the URL of the HTTP trigger from the output panel. The URL that calls your HTTP-triggered function must be in this format:

   https://<functionappname>.chinacloudsites.cn/api/orchestrators/HelloOrchestrator

1. Copy the URL of the HTTP trigger from the output panel. The URL that calls your HTTP-triggered function must be in this format:

   https://<functionappname>.chinacloudsites.cn/api/orchestrators/hello_orchestrator