Merge pull request #244799 from ggailey777/patch-2

JamesJBarnett · web-flow · commit 6705b9a4d981 · 2023-07-15T15:44:41.000-07:00
[Functions] Fix v2 procedure and make clear that the `EnableWorkerIndexing` flag is required
diff --git a/articles/azure-functions/create-first-function-cli-python.md b/articles/azure-functions/create-first-function-cli-python.md
@@ -1,7 +1,7 @@
 ---
 title: Create a Python function from the command line - Azure Functions
 description: Learn how to create a Python function from the command line, then publish the local project to serverless hosting in Azure Functions.
-ms.date: 03/22/2023
+ms.date: 07/15/2023
 ms.topic: quickstart
 ms.devlang: python
 ms.custom: devx-track-python, devx-track-azurecli, devx-track-azurepowershell, mode-api, devdivchpfy22
@@ -28,12 +28,8 @@ Before you begin, you must have the following requirements in place:
 
 + An Azure account with an active subscription. [Create an account for free](https://azure.microsoft.com/free/?ref=microsoft.com&utm_source=microsoft.com&utm_medium=docs&utm_campaign=visualstudio).
 
-::: zone pivot="python-mode-configuration"  
 + The [Azure Functions Core Tools](functions-run-local.md#v2) version 4.x.
-::: zone-end
-::: zone pivot="python-mode-decorators"  
-+ The [Azure Functions Core Tools](functions-run-local.md#v2) version 4.2.1 or later.
-::: zone-end  
+
 + One of the following tools for creating Azure resources:
 
   + [Azure CLI](/cli/azure/install-azure-cli) version 2.4 or later.
@@ -47,36 +43,6 @@ Before you begin, you must have the following requirements in place:
 
 [!INCLUDE [functions-x86-emulation-on-arm64-note](../../includes/functions-x86-emulation-on-arm64-note.md)]
 
-### Prerequisite check
-
-Verify your prerequisites, which depend on whether you're using Azure CLI or Azure PowerShell for creating Azure resources.
-
-# [Azure CLI](#tab/azure-cli)
-
-::: zone pivot="python-mode-configuration"
-+ In a terminal or command window, run `func --version` to check that the Azure Functions Core Tools version is 4.x.
-::: zone-end
-::: zone pivot="python-mode-decorators"
-+ In a terminal or command window, run `func --version` to check that the Azure Functions Core Tools version is 4.0.4785 or later.
-::: zone-end
-+ Run `az --version` to check that the Azure CLI version is 2.4 or later.
-
-+ Run `az login` to sign in to Azure and verify an active subscription.
-
-+ Run `python --version` (Linux/macOS) or `py --version` (Windows) to check your Python version reports 3.9.x, 3.8.x, or 3.7.x.
-
-# [Azure PowerShell](#tab/azure-powershell)
-
-+ In a terminal or command window, run `func --version` to check that the Azure Functions Core Tools version is 4.x.
-
-+ Run `(Get-Module -ListAvailable Az).Version` and verify version 5.0 or later.
-
-+ Run `Connect-AzAccount` to sign in to Azure and verify an active subscription.
-
-+ Run `python --version` (Linux/macOS) or `py --version` (Windows) to check your Python version reports 3.9.x, 3.8.x, or 3.7.x.
-
----
-
 ## <a name="create-venv"></a>Create and activate a virtual environment
 
 In a suitable folder, run the following commands to create and activate a virtual environment named `.venv`. Make sure that you're using Python 3.9, 3.8, or 3.7, which are supported by Azure Functions.
@@ -146,15 +112,9 @@ In Azure Functions, a function project is a container for one or more individual
     func new --name HttpExample --template "HTTP trigger" --authlevel "anonymous"
     ```
 
-    `func new` creates a subfolder matching the function name that contains a code file appropriate to the project's chosen language and a configuration file named *function.json*.
-
-    Get the list of templates by using the following command:
-
-    ```console
-    func templates list -l python
-    ```
-::: zone-end
-::: zone pivot="python-mode-decorators"
+    `func new` creates a subfolder matching the function name that contains a code file appropriate to the project's chosen language and a configuration file named *function.json*.    
+::: zone-end  
+::: zone pivot="python-mode-decorators"  
 1. Run the `func init` command as follows to create a functions project in a folder named *LocalFunctionProj* with the specified runtime and the specified programming model version.
 
     ```console
@@ -166,51 +126,33 @@ In Azure Functions, a function project is a container for one or more individual
     ```console
     cd LocalFunctionProj
     ```
-
+    
     This folder contains various files for the project, including configuration files named [*local.settings.json*](functions-develop-local.md#local-settings-file) and [*host.json*](functions-host-json.md). Because *local.settings.json* can contain secrets downloaded from Azure, the file is excluded from source control by default in the *.gitignore* file.
 
 1. The file `function_app.py` can include all functions within your project. To start with, there's already an HTTP function stored in the file.
 
-```python
-import azure.functions as func
-
-app = func.FunctionApp()
-
-@app.function_name(name="HttpTrigger1")
-@app.route(route="hello")
-def test_function(req: func.HttpRequest) -> func.HttpResponse:
-    return func.HttpResponse("HttpTrigger1 function processed a request!")
-```
-::: zone-end
-
-### (Optional) Examine the file contents
-
-If desired, you can skip to [Run the function locally](#run-the-function-locally) and examine the file contents later.
-
-::: zone pivot="python-mode-configuration"
-#### \_\_init\_\_.py
-
-*\_\_init\_\_.py* contains a `main()` Python function that's triggered according to the configuration in *function.json*.
-
-:::code language="python" source="~/functions-quickstart-templates/Functions.Templates/Templates/HttpTrigger-Python/__init__.py":::
-
-For an HTTP trigger, the function receives request data in the variable `req` as defined in *function.json*. `req` is an instance of the [azure.functions.HttpRequest class](/python/api/azure-functions/azure.functions.httprequest). The return object, defined as `$return` in *function.json*, is an instance of [azure.functions.HttpResponse class](/python/api/azure-functions/azure.functions.httpresponse). For more information, see [Azure Functions HTTP triggers and bindings](./functions-bindings-http-webhook.md?tabs=python).
-
-#### function.json
-
-*function.json* is a configuration file that defines the input and output `bindings` for the function, including the trigger type.
-
-If desired, you can change `scriptFile` to invoke a different Python file.
-
-:::code language="json" source="~/functions-quickstart-templates/Functions.Templates/Templates/HttpTrigger-Python/function.json":::
-
-Each binding requires a direction, a type, and a unique name. The HTTP trigger has an input binding of type [`httpTrigger`](functions-bindings-http-webhook-trigger.md) and output binding of type [`http`](functions-bindings-http-webhook-output.md).
-::: zone-end
-::: zone pivot="python-mode-decorators"
-`function_app.py` is the entry point to the function and where functions will be stored and/or referenced. This file will include configuration of triggers and bindings through decorators, and the function content itself. 
-
-For more information, see [Azure Functions HTTP triggers and bindings](./functions-bindings-http-webhook.md?tabs=python).
+   ```python
+   import azure.functions as func
+  
+   app = func.FunctionApp()
+  
+   @app.function_name(name="HttpTrigger1")
+   @app.route(route="hello")
+   def test_function(req: func.HttpRequest) -> func.HttpResponse:
+       return func.HttpResponse("HttpTrigger1 function processed a request!")
+   ```
+   
+1. Open the local.settings.json project file and verify that the `AzureWebJobsFeatureFlags` setting has a value of `EnableWorkerIndexing`. This is required for Functions to interpret your project correctly as the Python v2 model. You'll add this same setting to your application settings after you publish your project to Azure. 
+
+1. In the local.settings.json file, update the `AzureWebJobsStorage` setting as in the following example:
+
+    ```json
+    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
+    ```
 
+    This tells the local Functions host to use the storage emulator for the storage connection currently required by the Python v2 model. When you publish your project to Azure, you'll need to instead use the default storage account. If you're instead using an Azure Storage account, set your storage account connection string here.   
+::: zone-end  
+::: zone pivot="python-mode-decorators"  
 ## Start the storage emulator
 
 By default, local development uses the Azurite storage emulator. This emulator is used when the `AzureWebJobsStorage` setting in the *local.settings.json* project file is set to `UseDevelopmentStorage=true`. When using the emulator, you must start the local Azurite storage emulator before running the function. 
diff --git a/articles/azure-functions/create-first-function-vs-code-python.md b/articles/azure-functions/create-first-function-vs-code-python.md
@@ -75,7 +75,6 @@ In this section, you use Visual Studio Code to create a local Azure Functions pr
     |**Select a template for your project's first function**| Choose `HTTP trigger`.|
     |**Provide a function name**| Enter `HttpExample`.|
     |**Authorization level**| Choose `Anonymous`, which lets anyone call your function endpoint. For more information about the authorization level, see [Authorization keys](functions-bindings-http-webhook-trigger.md#authorization-keys).|
-    |**Select how you would like to open your project**| Choose `Open in current window`.|
 
 4. Visual Studio Code uses the provided information and generates an Azure Functions project with an HTTP trigger. You can view the local project files in the Explorer. For more information about the files that are created, see [Generated project files](functions-develop-vs-code.md?tabs=python#generated-project-files).
 ::: zone-end
@@ -86,56 +85,21 @@ In this section, you use Visual Studio Code to create a local Azure Functions pr
     |--|--|
     |**Select a language**| Choose `Python (Programming Model V2)`.|
     |**Select a Python interpreter to create a virtual environment**| Choose your preferred Python interpreter. If an option isn't shown, type in the full path to your Python binary.|
-    |**Select how you would like to open your project**| Choose `Open in current window`.|
+    |**Select a template for your project's first function** | Choose `HTTP trigger`. |
+    |**Name of the function you want to create**| Enter `HttpExample`.|
+    |**Authorization level**| Choose `ANONYMOUS`, which lets anyone call your function endpoint. For more information about the authorization level, see [Authorization keys](functions-bindings-http-webhook-trigger.md#authorization-keys).|
 
-4. Visual Studio Code uses the provided information and generates an Azure Functions project.   
-
-5. Open the generated `function_app.py` project file, which contains your functions.
-
-6. Uncomment the `test_function` function, which is an HTTP triggered function.
-
-7. Replace the `app.route()` method call with the following code:
-
-    ```python
-    @app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)
-    ```
-
-    This code enables your HTTP function endpoint to be called in Azure without having to provide an [Authorization keys](functions-bindings-http-webhook-trigger.md#authorization-keys). Local execution doesn't require authorization keys. 
-
-    Your function code should now look like the following example:
-
-    ```python
-    app = func.FunctionApp()
-    @app.function_name(name="HttpTrigger1")
-    @app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)
-    def test_function(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}. This HTTP triggered function executed successfully.")
-        else:
-            return func.HttpResponse(
-                "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
-                status_code=200
-            ) 
-    ```
+4. Visual Studio Code uses the provided information and generates an Azure Functions project with an HTTP trigger. You can view the local project files in the Explorer. The generated `function_app.py` project file contains your functions.   
  
-8. Open the local.settings.json project file and updated the `AzureWebJobsStorage` setting as in the following example:
+5. Open the local.settings.json project file and verify that the `AzureWebJobsFeatureFlags` setting has a value of `EnableWorkerIndexing`. This is required for Functions to interpret your project correctly as the Python v2 model. You'll add this same setting to your application settings after you publish your project to Azure. 
+
+6. In the local.settings.json file, update the `AzureWebJobsStorage` setting as in the following example:
 
     ```json
     "AzureWebJobsStorage": "UseDevelopmentStorage=true",
     ```
 
-    This tells the local Functions host to use the storage emulator for the storage connection currently required by the v2 model. When you publish your project to Azure, you'll instead use the default storage account. If you're instead using an Azure Storage account, set your storage account connection string here.
+    This tells the local Functions host to use the storage emulator for the storage connection currently required by the Python v2 model. When you publish your project to Azure, you'll need to instead use the default storage account. If you're instead using an Azure Storage account, set your storage account connection string here.
 
 ## Start the emulator
 
diff --git a/articles/azure-functions/functions-machine-learning-tensorflow.md b/articles/azure-functions/functions-machine-learning-tensorflow.md
@@ -111,7 +111,7 @@ In Azure Functions, a function project is a container for one or more individual
     func new --name classify --template "HTTP trigger"
     ```
 
-    This command creates a folder matching the name of the function, *classify*. In that folder are two files: *\_\_init\_\_.py*, which contains the function code, and *function.json*, which describes the function's trigger and its input and output bindings. For details on the contents of these files, see [Examine the file contents](./create-first-function-cli-python.md#optional-examine-the-file-contents) in the Python quickstart.
+    This command creates a folder matching the name of the function, *classify*. In that folder are two files: *\_\_init\_\_.py*, which contains the function code, and *function.json*, which describes the function's trigger and its input and output bindings. For details on the contents of these files, see [Programming model](./functions-reference-python.md?pivots=python-mode-configuration#programming-model) in the Python developer guide.
 
 
 ## Run the function locally
diff --git a/articles/azure-functions/machine-learning-pytorch.md b/articles/azure-functions/machine-learning-pytorch.md
@@ -109,7 +109,7 @@ In Azure Functions, a function project is a container for one or more individual
     func new --name classify --template "HTTP trigger"
     ```
 
-    This command creates a folder matching the name of the function, *classify*. In that folder are two files: *\_\_init\_\_.py*, which contains the function code, and *function.json*, which describes the function's trigger and its input and output bindings. For details on the contents of these files, see [Examine the file contents](./create-first-function-cli-python.md#optional-examine-the-file-contents) in the Python quickstart.
+    This command creates a folder matching the name of the function, *classify*. In that folder are two files: *\_\_init\_\_.py*, which contains the function code, and *function.json*, which describes the function's trigger and its input and output bindings. For details on the contents of these files, see [Programming model](./functions-reference-python.md?pivots=python-mode-configuration#programming-model) in the Python developer guide.
 
 
 ## Run the function locally
