Correct the tutorial Django articles so there isn't multiple include applies to references in them

markingmyname · markingmyname · commit cfe69ce03633 · 2022-09-20T10:35:54.000-05:00
diff --git a/articles/postgresql/flexible-server/tutorial-django-aks-database.md b/articles/postgresql/flexible-server/tutorial-django-aks-database.md
@@ -95,6 +95,7 @@ aks-nodepool1-31718369-0   Ready    agent   6m44s   v1.12.8
 ```
 
 ## Create an Azure Database for PostgreSQL - Flexible Server
+
 Create a flexible server with the [az postgreSQL flexible-server create](/cli/azure/postgres/flexible-server#az-postgres-flexible-server-create) command. The following command creates a server using service defaults and values from your Azure CLI's local context:
 
 ```azurecli-interactive
@@ -107,13 +108,11 @@ The server created has the below attributes:
 - Using public-access argument allow you to create a server with public access to any client with correct username and password.
 - Since the command is using local context it will create the server in the resource group ```django-project``` and in the region ```eastus```.
 
-
 ## Build your Django docker image
 
 Create a new [Django application](https://docs.djangoproject.com/en/3.1/intro/) or use your existing Django project. Make sure your code is in this folder structure. 
 
-
-```
+```python
 └───my-djangoapp
     └───views.py
     └───models.py
@@ -130,8 +129,8 @@ Create a new [Django application](https://docs.djangoproject.com/en/3.1/intro/)
     └─── Dockerfile
     └─── requirements.txt
     └─── manage.py
-    
 ```
+
 Update ```ALLOWED_HOSTS``` in ```settings.py``` to make sure the Django application uses the external IP that gets assigned to kubernetes app.
 
 ```python
@@ -171,42 +170,35 @@ Create a new file named ```Dockerfile``` and copy the code snippet below. This D
 ```docker
 # Use the official Python image from the Docker Hub
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 FROM python:3.8.2
 
 # Make a new directory to put our code in.
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 RUN mkdir /code
 
 # Change the working directory.
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 WORKDIR /code
 
 # Copy to code folder
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 COPY . /code/
 
 # Install the requirements.
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 RUN pip install -r requirements.txt
 
 # Run the application:
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
+
 CMD python manage.py runserver 0.0.0.0:8000
 ```
 
 ### Build your image
 Make sure you're in the directory ```my-django-app``` in a terminal using the ```cd``` command. Run the following command to build your bulletin board image:
 
-``` bash
-
+```bash
 docker build --tag myblog:latest .
-
 ```
 
 Deploy your image to [Docker hub](https://docs.docker.com/get-started/part3/#create-a-docker-hub-repository-and-push-your-image) or [Azure Container registry](../../container-registry/container-registry-get-started-azure-cli.md).
@@ -217,7 +209,6 @@ Deploy your image to [Docker hub](https://docs.docker.com/get-started/part3/#cre
 >```azurecli-interactive
 >az aks update -n djangoappcluster -g django-project --attach-acr <your-acr-name>
 > ```
->
 
 ## Create Kubernetes manifest file
 
@@ -327,13 +318,14 @@ Now open a web browser to the external IP address of your service (http://\<serv
 
 ## Run database migrations
 
-For any django application, you would need to run database migration or collect static files. You can run these django shell commands using ```$ kubectl exec <pod-name> -- [COMMAND]```.  Before running the command you need to find the pod name using ```kubectl get pods```. 
+For any django application, you would need to run database migration or collect static files. You can run these django shell commands using `$ kubectl exec <pod-name> -- [COMMAND]`.  Before running the command you need to find the pod name using `kubectl get pods`. 
 
 ```bash
 $ kubectl get pods
 ```
 
-You will see an output like this
+You will see an output like this:
+
 ```output
 NAME                             READY   STATUS          RESTARTS   AGE
 django-app-5d9cd6cd8-l6x4b     1/1     Running              0       2m
diff --git a/articles/postgresql/flexible-server/tutorial-django-app-service-postgres.md b/articles/postgresql/flexible-server/tutorial-django-app-service-postgres.md
@@ -16,15 +16,15 @@ ms.custom: mvc, devx-track-azurecli
 
 [!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 
-In this tutorial you will learn how to deploy a Django application in Azure using App Services and Azure Database for PostgreSQL - Flexible Server in a virtual network.
+In this tutorial you'll learn how to deploy a Django application in Azure using App Services and Azure Database for PostgreSQL - Flexible Server in a virtual network.
 
 ## Prerequisites
 
 If you don't have an Azure subscription, create a [free](https://azure.microsoft.com/free/) account before you begin.
 
 This article requires that you're running the Azure CLI version 2.0 or later locally. To see the version installed, run the `az --version` command. If you need to install or upgrade, see [Install Azure CLI](/cli/azure/install-azure-cli).
 
-You'll need to login to your account using the [az login](/cli/azure/authenticate-azure-cli) command. Note the **id** property from the command output for the corresponding subscription name.
+You'll need to log in to your account using the [az login](/cli/azure/authenticate-azure-cli) command. Note the **id** property from the command output for the corresponding subscription name.
 
 ```azurecli
 az login
@@ -35,28 +35,25 @@ If you have multiple subscriptions, choose the appropriate subscription in which
 ```azurecli
 az account set --subscription <subscription id>
 ```
+
 ## Clone or download the sample app
 
 # [Git clone](#tab/clone)
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
-
 Clone the sample repository:
 
-```terminal
+```console
 git clone https://github.com/Azure-Samples/djangoapp
 ```
 
 Then go into that folder:
 
-```terminal
+```console
 cd djangoapp
 ```
 
 # [Download](#tab/download)
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
-
 Visit [https://github.com/Azure-Samples/djangoapp](https://github.com/Azure-Samples/djangoapp), select **Clone**, and then select **Download ZIP**.
 
 Unpack the ZIP file into a folder named *djangoapp*.
@@ -77,61 +74,49 @@ These changes are specific to configuring Django to run in any production enviro
 ## Create a PostgreSQL Flexible Server in a new virtual network
 
 Create a private flexible server and a database inside a virtual network (VNET) using the following command:
+
 ```azurecli
 # Create Flexible server in a VNET
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
-
 az postgres flexible-server create --resource-group myresourcegroup --location westus2
-
 ```
 
 This command performs the following actions, which may take a few minutes:
 
 - Create the resource group if it doesn't already exist.
-- Generates a server name if it is not provided.
+- Generates a server name if it isn't provided.
 - Create a new virtual network for your new postgreSQL server. **Make a note of virtual network name and subnet name** created for your server since you need to add the web app to the same virtual network.
-- Creates admin username , password for your server if not provided. **Make a note of the username and password** to use in the next step.
+- Creates admin username, password for your server if not provided. **Make a note of the username and password** to use in the next step.
 - Create a database ```postgres``` that can be used for development. You can run [**psql** to connect to the database](quickstart-create-server-portal.md#connect-to-the-postgresql-database-using-psql) to create a different database.
 
 > [!NOTE]
-> Make a note of your password that will be generate for you if not provided. If you forget the password you would have to reset the password using ``` az postgres flexible-server update``` command
-
+> Make a note of your password that will be generate for you if not provided. If you forget the password you would have to reset the password using `az postgres flexible-server update` command
 
 ## Deploy the code to Azure App Service
 
 In this section, you create app host in App Service app, connect this app to the Postgres database, then deploy your code to that host.
 
-
 ### Create the App Service web app in a virtual network
 
 In the terminal, make sure you're in the repository root (`djangoapp`) that contains the app code.
 
 Create an App Service app (the host process) with the [`az webapp up`](/cli/azure/webapp#az-webapp-up) command:
 
 ```azurecli
-
 # Create a web app
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 az webapp up --resource-group myresourcegroup --location westus2 --plan DjangoPostgres-tutorial-plan --sku B1 --name <app-name>
 
 # Enable VNET integration for web app.
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 # Replace <vnet-name> and <subnet-name> with the virtual network and subnet name that the flexible server is using.
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
-
 az webapp vnet-integration add -g myresourcegroup -n  mywebapp --vnet <vnet-name> --subnet <subnet-name>
 
 # Configure database information as environment variables
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 # Use the postgres server name , database name , username , password for the database created in the previous steps
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
-
 az webapp config appsettings set --settings DJANGO_ENV="production" DBHOST="<postgres-server-name>.postgres.database.azure.com" DBNAME="postgres" DBUSER="<username>" DBPASS="<password>"
 ```
 - For the `--location` argument, use the same location as you did for the database in the previous section.
@@ -141,7 +126,7 @@ az webapp config appsettings set --settings DJANGO_ENV="production" DBHOST="<pos
 - Enable default logging for the app, if not already enabled.
 - Upload the repository using ZIP deployment with build automation enabled.
 - **az webapp vnet-integration** command adds the web app in the same virtual network as the postgres server.
-- The app code expects to find database information in a number of environment variables. To set environment variables in App Service, you create "app settings" with the [az webapp config appsettings set](/cli/azure/webapp/config/appsettings#az-webapp-config-appsettings-set) command.
+- The app code expects to find database information in many environment variables. To set environment variables in App Service, you create "app settings" with the [az webapp config appsettings set](/cli/azure/webapp/config/appsettings#az-webapp-config-appsettings-set) command.
 
 > [!TIP]
 > Many Azure CLI commands cache common parameters, such as the name of the resource group and App Service plan, into the file *.azure/config*. As a result, you don't need to specify all the same parameter with later commands. For example, to redeploy the app after making changes, you can just run `az webapp up` again without any parameters.
@@ -152,7 +137,7 @@ Django database migrations ensure that the schema in the PostgreSQL on Azure dat
 
 1. Open an SSH session in the browser by navigating to *https://\<app-name>.scm.azurewebsites.net/webssh/host* and sign in with your Azure account credentials (not the database server credentials).
 
-1. In the SSH session, run the following commands (you can paste commands using **Ctrl**+**Shift**+**V**):
+2. In the SSH session, run the following commands (you can paste commands using **Ctrl**+**Shift**+**V**):
 
     ```bash
     cd site/wwwroot
@@ -167,15 +152,15 @@ Django database migrations ensure that the schema in the PostgreSQL on Azure dat
     python manage.py createsuperuser
     ```
 
-1. The `createsuperuser` command prompts you for superuser credentials. For the purposes of this tutorial, use the default username `root`, press **Enter** for the email address to leave it blank, and enter `postgres1` for the password.
+3. The `createsuperuser` command prompts you for superuser credentials. For the purposes of this tutorial, use the default username `root`, press **Enter** for the email address to leave it blank, and enter `postgres1` for the password.
 
 ### Create a poll question in the app
 
-1. In a browser, open the URL *http:\//\<app-name>.azurewebsites.net*. The app should display the message "No polls are available" because there are no specific polls yet in the database.
+4. In a browser, open the URL *http:\//\<app-name>.azurewebsites.net*. The app should display the message "No polls are available" because there are no specific polls yet in the database.
 
-1. Browse to *http:\//\<app-name>.azurewebsites.net/admin*. Sign in using superuser credentials from the previous section (`root` and `postgres1`). Under **Polls**, select **Add** next to **Questions** and create a poll question with some choices.
+5. Browse to *http:\//\<app-name>.azurewebsites.net/admin*. Sign in using superuser credentials from the previous section (`root` and `postgres1`). Under **Polls**, select **Add** next to **Questions** and create a poll question with some choices.
 
-1. Browse again to *http:\//\<app-name>.azurewebsites.net/* to confirm that the questions are now presented to the user. Answer questions however you like to generate some data in the database.
+6. Browse again to *http:\//\<app-name>.azurewebsites.net/* to confirm that the questions are now presented to the user. Answer questions however you like to generate some data in the database.
 
 **Congratulations!** You're running a Python Django web app in Azure App Service for Linux, with an active Postgres database.
 
@@ -193,25 +178,20 @@ In a terminal window, run the following commands. Be sure to follow the prompts
 ```bash
 # Configure the Python virtual environment
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 python3 -m venv venv
 source venv/bin/activate
 
 # Install packages
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 pip install -r requirements.txt
 # Run Django migrations
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 python manage.py migrate
 # Create Django superuser (follow prompts)
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 python manage.py createsuperuser
 # Run the dev server
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 python manage.py runserver
 ```
 Once the web app is fully loaded, the Django development server provides the local app URL in the message, "Starting development server at http://127.0.0.1:8000/. Quit the server with CTRL-BREAK".
@@ -222,30 +202,27 @@ Test the app locally with the following steps:
 
 1. Go to *http:\//localhost:8000* in a browser, which should display the message "No polls are available".
 
-1. Go to *http:\//localhost:8000/admin* and sign in using the admin user you created previously. Under **Polls**, again select **Add** next to **Questions** and create a poll question with some choices.
+2. Go to *http:\//localhost:8000/admin* and sign in using the admin user you created previously. Under **Polls**, again select **Add** next to **Questions** and create a poll question with some choices.
 
-1. Go to *http:\//localhost:8000* again and answer the question to test the app.
+3. Go to *http:\//localhost:8000* again and answer the question to test the app.
 
-1. Stop the Django server by pressing **Ctrl**+**C**.
+4. Stop the Django server by pressing **Ctrl**+**C**.
 
 When running locally, the app is using a local Sqlite3 database and doesn't interfere with your production database. You can also use a local PostgreSQL database, if desired, to better simulate your production environment.
 
-
-
 ### Update the app
 
 In `polls/models.py`, locate the line that begins with `choice_text` and change the `max_length` parameter to 100:
 
 ```python
 # Find this lie of code and set max_length to 100 instead of 200
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 choice_text = models.CharField(max_length=100)
 ```
 
 Because you changed the data model, create a new Django migration and migrate the database:
 
-```
+```python
 python manage.py makemigrations
 python manage.py migrate
 ```
@@ -265,8 +242,6 @@ az webapp up
 
 This command uses the parameters cached in the *.azure/config* file. Because App Service detects that the app already exists, it just redeploys the code.
 
-
-
 ### Rerun migrations in Azure
 
 Because you made changes to the data model, you need to rerun database migrations in App Service.
@@ -278,11 +253,9 @@ cd site/wwwroot
 
 # Activate default virtual environment in App Service container
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 source /antenv/bin/activate
 # Run database migrations
 
-[!INCLUDE [applies-to-postgresql-flexible-server](../includes/applies-to-postgresql-flexible-server.md)]
 python manage.py migrate
 ```
 
@@ -304,7 +277,6 @@ By default, the portal shows your app's **Overview** page, which provides a gene
 
 :::image type="content" source="./media/tutorial-django-app-service-postgres/manage-django-app-in-app-services-in-the-azure-portal.png" alt-text="Manage your Python Django app in the Overview page in the Azure portal":::
 
-
 ## Clean up resources
 
 If you'd like to keep the app or continue to the next tutorial, skip ahead to [Next steps](#next-steps). Otherwise, to avoid incurring ongoing charges you can delete the resource group create for this tutorial:
