1561426, incorporated first round of peer review feedback.

Author: john-par

articles/azure-functions/functions-create-first-function-python.md

@@ -15,7 +15,7 @@ manager: gwallace
 
 This article shows you how to use command-line tools to create a Python project that runs in Azure Functions. An HTTP request triggers the function you create. Finally, you publish your project to run as a [serverless function](functions-scale.md#consumption-plan) in Azure.
 
-This article is the first of two quickstarts for Azure Functions. After you complete this article, you [add an Azure Storage queue output binding](functions-add-output-binding-storage-queue-python.md) to your function.
+This article is the first of two Python quickstarts for Azure Functions. After you complete this quickstart, you can [add an Azure Storage queue output binding](functions-add-output-binding-storage-queue-python.md) to your function.
 
 ## Prerequisites
 
@@ -29,11 +29,11 @@ Before you start, you must:
 
 + Have an active Azure subscription.
 
-[!INCLUDE [quickstarts-free-trial-note](../../includes/quickstarts-free-trial-note.md)]
+    [!INCLUDE [quickstarts-free-trial-note](../../includes/quickstarts-free-trial-note.md)]
 
 ## Create and activate a virtual environment (optional)
 
-To locally develop and test Python functions, it's recommended to use a Python 3.6.x environment. Run the following commands to create and activate a virtual environment named `.venv`.
+You can use a Python 3.6.x environment to locally develop and test Python functions. Run the following commands to create and activate a virtual environment named `.venv`.
 
 > [!NOTE]
 > If Python didn't install venv on your Linux distribution, you can install it using the following command:
@@ -54,15 +54,11 @@ py -m venv .venv
 .venv\scripts\activate
 ```
 
-Now that the virtualenv is activated, you'll run the remaining commands in it. If you want to get out of the virtual environment, run this command:
+Now that you activated the virtual environment, run the remaining commands in it. To get out of the virtual environment, run `deactivate`.
 
-```console
-deactivate
-```
-
-## Create a local Functions project
+## Create a local functions project
 
-A Functions project is the equivalent of a function app in Azure. It can have multiple functions that all share the same local and hosting configurations.
+A functions project is the equivalent of a function app in Azure. It can have multiple functions that all share the same local and hosting configurations.
 
 1. In the virtual environment, run the following command:
 
@@ -74,9 +70,9 @@ A Functions project is the equivalent of a function app in Azure. It can have mu
 
     The command creates a _MyFunctionProj_ folder. It contains these three files:
 
-    * `local.settings.json`: used to store app settings and connection strings when running locally. This file doesn't get published to Azure.
-    * `requirements.txt`: contains the list of packages the system will install on publishing to Azure.
-    * `host.json`: contains global configuration options that affect all functions in a function app. This file does get published to Azure.
+    * *local.settings.json*: used to store app settings and connection strings when running locally. This file doesn't get published to Azure.
+    * *requirements.txt*: contains the list of packages the system will install on publishing to Azure.
+    * *host.json*: contains global configuration options that affect all functions in a function app. This file does get published to Azure.
 
 1. Go to the new *MyFunctionProj* folder:
 
@@ -86,7 +82,7 @@ A Functions project is the equivalent of a function app in Azure. It can have mu
 
 ## Create a function
 
-Now it's time to create a function for the new project.
+Add a function to the new project.
 
 1. To add a function to your project, run the following command:
 
@@ -100,25 +96,25 @@ Now it's time to create a function for the new project.
 
 These commands create a subfolder named _HttpTrigger_. It contains the following files:
 
-* **function.json**: configuration file that defines the function, trigger, and other bindings. Take a look at this file. Notice that the value for `scriptFile` points to the file containing the function, while the system defines the invocation trigger and bindings in the `bindings` array.
+* *function.json*: configuration file that defines the function, trigger, and other bindings. Notice that in this file, the value for `scriptFile` points to the file containing the function, and the `bindings` array defines the invocation trigger and bindings.
 
     Each binding requires a direction, type and a unique name. The HTTP trigger has an input binding of type [`httpTrigger`](functions-bindings-http-webhook.md#trigger) and output binding of type [`http`](functions-bindings-http-webhook.md#output).
 
-* **\_\_init\_\_.py**: script file that is your HTTP triggered function. Open the script. Take note that it contains a default `main()`. HTTP data from the trigger is passed to this function using the `req` named binding parameter. Defined in function.json, `req` is an instance of the [azure.functions.HttpRequest class](/python/api/azure-functions/azure.functions.httprequest). 
+* *\_\_init\_\_.py*: script file that is your HTTP triggered function. Notice that this script has a default `main()`. HTTP data from the trigger passes to the function using the `req` named `binding parameter`. The `req`, which is defined in function.json, 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). To learn more, see [Azure Functions HTTP triggers and bindings](functions-bindings-http-webhook.md).
 
 ## Run the function locally
 
-The function runs locally using the same Azure Functions runtime that is in Azure.
+The function runs locally using the Azure Functions runtime.
 
 1. This command starts the function app:
 
     ```console
     func host start
     ```
 
-    When the Functions host starts, it writes something like the following output. It's truncated so you can read it better:
+    When the Azure Functions host starts, it writes something like the following output. It's truncated here so you can read it better:
 
     ```output
     
@@ -150,11 +146,9 @@ The function runs locally using the same Azure Functions runtime that is in Azur
     [8/27/2018 10:38:27 PM] Job host started
     ```
 
-1. Copy the URL of your `HttpTrigger` function from the runtime output.
+1. Copy the URL of your `HttpTrigger` function from the runtime output and paste it into your browser's address bar.
 
-1.  Paste it into your browser's address bar.
-
-1. Append the query string `?name=<yourname>` to this URL and execute the request. The following screenshot shows the response in the browser to the GET request returned by the local function:
+1. Append the query string `?name=<yourname>` to this URL and execute the request. The following screenshot shows the response to the GET request that the local function returns to the browser:
 
     ![Test locally in the browser](./media/functions-create-first-function-python/function-test-local-browser.png)
 
@@ -172,29 +166,30 @@ A function app provides an environment for executing your function code. It lets
 
 Run the following command. Replace `<APP_NAME>` with a unique function app name. Replace `<STORAGE_NAME>` with a storage account name. The `<APP_NAME>` is also the default DNS domain for the function app. This name needs to be unique across all apps in Azure.
 
+> [!NOTE]
+> You can't host Linux and Windows apps in the same resource group. If you have an existing resource group named `myResourceGroup` with a Windows function app or web app, you must use a different resource group.
+
 ```azurecli-interactive
 az functionapp create --resource-group myResourceGroup --os-type Linux \
 --consumption-plan-location westeurope  --runtime python \
 --name <APP_NAME> --storage-account  <STORAGE_NAME>
 ```
-> [!NOTE]
-> You can't host Linux and Windows apps in the same resource group. If you have an existing resource group named `myResourceGroup` with a Windows function app or web app, you must use a different resource group.
 
-This command will also provision an associated Azure Application Insights instance. It will be in the same resource group that you can use for monitoring and viewing logs.
+The preceeding command will also provision an associated Azure Application Insights instance. It will be in the same resource group, which you can use for monitoring and viewing logs.
 
 You're now ready to publish your local functions project to the function app in Azure.
 
 ## Deploy the function app project to Azure
 
-After the function app is created in Azure, you can use the [func azure functionapp publish](functions-run-local.md#project-file-deployment) Core Tools command to deploy your project code to Azure. In these examples, replace `<APP_NAME>` with the name of your app from the previous step.
+After you create the function app in Azure, you can use the [func azure functionapp publish](functions-run-local.md#project-file-deployment) Core Tools command to deploy your project code to Azure. In this examples, replace `<APP_NAME>` with the name of your app.
 
 ```azurecli-interactive
 func azure functionapp publish <APP_NAME> --build remote
 ```
 
 The `--build remote` option builds your Python project remotely in Azure from the files in the deployment package. 
 
-You'll see output similar to the following message. It's truncated so you can read it better:
+You'll see output similar to the following message. It's truncated here so you can read it better:
 
 ```output
 Getting site publishing info...
@@ -210,12 +205,12 @@ Functions in myfunctionapp:
         Invoke url: https://myfunctionapp.azurewebsites.net/api/httptrigger?code=cCr8sAxfBiow548FBDLS1....
 ```
 
-Copy the `Invoke url` value for your `HttpTrigger`. You can use it to test your function in Azure. The URL contains a `code` query string value. It's your function key. This key makes it difficult for others to call your HTTP trigger endpoint in Azure.
+You can copy the `Invoke url` value for your `HttpTrigger` and use it to test your function in Azure. The URL contains a `code` query string value that is your function key, which makes it difficult for others to call your HTTP trigger endpoint in Azure.
 
 [!INCLUDE [functions-test-function-code](../../includes/functions-test-function-code.md)]
 
 > [!NOTE]
-> To view near real-time logs for a published Python app, we recommend using the [Application Insights Live Metrics Stream](functions-monitoring.md#streaming-logs)
+> To view near real-time logs for a published Python app, use the [Application Insights Live Metrics Stream](functions-monitoring.md#streaming-logs).
 
 ## Next steps
 

includes/functions-create-resource-group.md

@@ -7,10 +7,10 @@ ms.author: glenga
 ---
 ## Create a resource group
 
-Create a resource group with the [az group create](/cli/azure/group). An Azure resource group is a logical container into which Azure resources like function apps, databases, and storage accounts are deployed and managed.
+Create a resource group with the [az group create](/cli/azure/group#az-group-create) command. An Azure resource group is a logical container into which Azure resources like function apps, databases, and storage accounts are deployed and managed.
 
 The following example creates a resource group named `myResourceGroup`.  
-If you are not using Cloud Shell, sign in first using `az login`.
+If you aren't using Cloud Shell, sign in first using `az login`.
 
 ```azurecli-interactive
 az group create --name myResourceGroup --location westeurope

includes/functions-create-storage-account.md

@@ -7,7 +7,7 @@ ms.author: glenga
 ---
 ## Create an Azure Storage account
 
-Functions uses a general-purpose account in Azure Storage to maintain state and other information about your functions. Create a general-purpose storage account in the resource group you created by using the [az storage account create](/cli/azure/storage/account) command.
+Functions uses a general-purpose account in Azure Storage to maintain state and other information about your functions. Create a general-purpose storage account in the resource group you created by using the [az storage account create](/cli/azure/storage/account#az-storage-account-create) command.
 
 In the following command, substitute a globally unique storage account name where you see the `<storage_name>` placeholder. Storage account names must be between 3 and 24 characters in length and may contain numbers and lowercase letters only.
 

includes/functions-test-function-code.md

@@ -11,6 +11,6 @@ Use cURL to test the deployed function. Using the URL, including the function ke
 
 ![using cURL to call the function in Azure.](./media/functions-test-function-code/functions-azure-cli-function-test-curl.png) 
 
-You can also paste the copied URL, including the function key, in to the address of your web browser. Again, append the query string `&name=<yourname>` to the URL before you execute the request.
+You can also paste the copied URL, including the function key, into the address bar of your web browser. Again, append the query string `&name=<yourname>` to the URL before you execute the request.
 
 ![Using a web browser to call the function.](./media/functions-test-function-code/functions-azure-cli-function-test-browser.png)