Merge pull request #248685 from alexwolfmsft/revert-pivots

v-regandowner · web-flow · commit 132589c7c79e · 2023-08-21T10:23:14.000-04:00
remove azd flow
diff --git a/articles/app-service/tutorial-python-postgresql-app.md b/articles/app-service/tutorial-python-postgresql-app.md
@@ -6,7 +6,6 @@ ms.topic: tutorial
 ms.date: 02/28/2023
 ms.author: msangapu
 ms.custom: mvc, seodec18, seo-python-october2019, cli-validate, devx-track-python, devdivchpfy22, event-tier1-build-2022, vscode-azure-extension-update-completed, AppServiceConnectivity
-zone_pivot_groups: deploy-python-web-app-postgresql
 ---
 
 # Deploy a Python (Django or Flask) web app with PostgreSQL in Azure
@@ -20,8 +19,6 @@ In this tutorial, you'll deploy a data-driven Python web app (**[Django](https:/
 * An Azure account with an active subscription. If you don't have an Azure account, you [can create one for free](https://azure.microsoft.com/free/python).
 * Knowledge of Python with Flask development or [Python with Django development](/training/paths/django-create-data-driven-websites/)
 
-:::zone pivot="deploy-portal"
-
 ## Sample application
 
 Sample Python applications using the Flask and Django framework are provided to help you follow along with this tutorial. To deploy them without running them locally, skip this part. 
@@ -519,260 +516,6 @@ If you can't connect to the SSH session, then the app itself has failed to start
 
 If you encounter any errors related to connecting to the database, check if the app settings (`AZURE_POSTGRESQL_CONNECTIONSTRING`) have been changed. Without that connection string, the migrate command can't communicate with the database. 
 
-:::zone-end
-
-:::zone pivot="deploy-azd"
-
-## Provision and deploy using the Azure Developer CLI
-
-Sample Python application templates using the Flask and Django framework are provided for this tutorial. The [Azure Developer CLI](/azure/developer/azure-developer-cli/overview) greatly streamlines the process of provisioning application resources and deploying code on Azure. For a more step-by-step approach using the Azure portal and other tools, toggle to the **Azure portal** approach at the top of the page.
-
-The Azure Developer CLI (azd) provides end-to-end support for project initialization, provisioning, deploying, monitoring and scaffolding a CI/CD pipeline to run against real Azure resources. You can use `azd` to provision and deploy the resources for the sample application in an automated and streamlined way.
-
-Follow the steps below to setup the Azure Developer CLI and provision and deploy the sample application:
-
-1. Install the Azure Developer CLI. For a full list of supported installation options and tools, visit the [installation guide](/azure/developer/azure-developer-cli/install-azd).
-
-    ### [Windows](#tab/windows)
-
-    ```azdeveloper
-    powershell -ex AllSigned -c "Invoke-RestMethod 'https://aka.ms/install-azd.ps1' | Invoke-Expression"
-    ```
-
-    ### [macOS/Linux](#tab/mac-linux)
-
-    ```azdeveloper
-    curl -fsSL https://aka.ms/install-azd.sh | bash 
-    ```
-
-    ---
-
-1. Run the `azd init` command to initialize the `azd` app template. Include the `--template` parameter to specify the name of an existing `azd` template you wish to use. More information about working with templates is available on the [choose an `azd` template](/azure/developer/azure-developer-cli/azd-templates) page.
-
-    ### [Flask](#tab/flask)
-
-    For this tutorial, Flask users should specify the [Python (Flask) web app with PostgresSQL](https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app.git) template.
-    
-    ```bash
-    azd init --template msdocs-flask-postgresql-sample-app
-    ```
-    
-    ### [Django](#tab/django)
-
-    For this tutorial, Django users should specify the [Python (Django) web app with PostgresSQL](https://github.com/Azure-Samples/msdocs-django-postgresql-sample-app.git) template.
-
-    ```bash
-    azd init --template msdocs-django-postgresql-sample-app
-    ```
-
-1. Run the `azd auth login` command to sign-in to Azure.
-
-    ```bash
-    azd auth login
-    ```
-
-1. Run the `azd up` command to provision the necessary Azure resources and deploy the app code. The `azd up` command will also prompt you to select the desired subscription and location to deploy to.
-
-    ```bash
-    azd up
-    ```
-
-1. When the `azd up` command finishes running, the URL for your deployed web app in the console will be printed. Click, or copy and paste the web app URL into your browser to explore the running app and verify that it is working correctly. All of the Azure resources and application code were set up for you by the `azd up` command.
-
-    The name of the resource group that was created is also displayed in the console output. Locate the resource group in the Azure portal to see all of the provisioned resources. 
-
-    :::image type="content" border="False" source="./media/tutorial-python-postgresql-app/azd-resources-small.png" lightbox="./media/tutorial-python-postgresql-app/azd-resources.png" alt-text="A screenshot showing the resources deployed by the Azure Developer CLI.":::
-
-The Azure Developer CLI also enables you to configure your application to use a CI/CD pipeline for deployments, setup monitoring functionality, and even remove the provisioned resources if you want to tear everything down. For more information about these additional workflows, visit the project [README](https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app/blob/main/README.md).
-
-## Explore the completed azd project template workflow
-
-The sections ahead review the steps that `azd` handled for you in more depth. You can explore this workflow to better understand the requirements for deploying your own apps to Azure. When you ran `azd up`, the Azure Developer CLI completed the following steps:
-
-> [!NOTE]
-> You can also use the steps outlined in the **Azure portal** version of this flow to gain additional insights into the tasks that `azd` completed for you.
-
-### 1. Cloned and initialized the project
-
-The `azd init` command cloned the sample app project template to your machine. The project template includes the following components:
-
-* **Source code**: The code and assets for a Flask or Django web app that can be used for local development or deployed to Azure.
-* **Bicep files**: Infrastructure as code (IaC) files that are used by `azd` to create the necessary resources in Azure.
-* **Configuration files**: Essential configuration files such as `azure.yaml` that are used by `azd` to provision, deploy and wire resources together to produce a fully fledged application.
-
-### 2. Provisioned the Azure resources
-
-The `azd up` command created all of the resources for the sample application in Azure using the Bicep files in the [`infra`](https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app/tree/main/infra) folder of the project template. [Bicep](/azure/azure-resource-manager/bicep/overview?tabs=bicep) is a declarative language used to manage Infrastructure as Code in Azure. Some of the key resources and configurations created by the template include:
-
-* **Resource group**: A resource group was created to hold all of the other provisioned Azure resources. The resource group keeps your resources well organized and easier to manage. The name of the resource group is based off of the environment name you specified during the `azd up` initialization process.
-* **Azure Virtual Network**: A virtual network was created to enable the provisioned resources to securely connect and communicate with one another. Related configurations such as setting up a private DNS zone link were also applied.
-* **Azure App Service plan**: An App Service plan was created to host App Service instances. App Service plans define what compute resources are available for one or more web apps.
-* **Azure App Service**: An App Service instance was created in the new App Service plan to host and run the deployed application. In this case a Linux instance was created and configured to run Python apps. Additional configurations were also applied to the app service, such as setting the Postgres connection string and secret keys. 
-* **Azure Database for PostgreSQL**: A Postgres database and server were created for the app hosted on App Service to connect to. The required admin user, network and connection settings were also configured.
-* **Azure Application Insights**: Application insights was set up and configured for the app hosted on the App Service. This service enables detailed telemetry and monitoring for your application.
-
-You can inspect the Bicep files in the [`infra`](https://github.com/Azure-Samples/msdocs-flask-postgresql-sample-app/tree/main/infra) folder of the project to understand how each of these resources were provisioned in more detail. The `resources.bicep` file defines most of the different services created in Azure. For example, the App Service plan and App Service web app instance were created and connected using the following Bicep code:
-
-### [Flask](#tab/flask)
-
-```yaml
-resource appServicePlan 'Microsoft.Web/serverfarms@2021-03-01' = {
-  name: '${prefix}-service-plan'
-  location: location
-  tags: tags
-  sku: {
-    name: 'B1'
-  }
-  properties: {
-    reserved: true
-  }
-}
-
-resource web 'Microsoft.Web/sites@2022-03-01' = {
-  name: '${prefix}-app-service'
-  location: location
-  tags: union(tags, { 'azd-service-name': 'web' })
-  kind: 'app,linux'
-  properties: {
-    serverFarmId: appServicePlan.id
-    siteConfig: {
-      alwaysOn: true
-      linuxFxVersion: 'PYTHON|3.10'
-      ftpsState: 'Disabled'
-      appCommandLine: 'startup.sh'
-    }
-    httpsOnly: true
-  }
-  identity: {
-    type: 'SystemAssigned'
-  }
-```
-
-### [Django](#tab/django)
-
-```yml
-resource appServicePlan 'Microsoft.Web/serverfarms@2021-03-01' = {
-  name: '${prefix}-service-plan'
-  location: location
-  tags: tags
-  sku: {
-    name: 'B1'
-  }
-  properties: {
-    reserved: true
-  }
-}
-
-resource web 'Microsoft.Web/sites@2022-03-01' = {
-  name: '${prefix}-app-service'
-  location: location
-  tags: union(tags, { 'azd-service-name': 'web' })
-  kind: 'app,linux'
-  properties: {
-    serverFarmId: appServicePlan.id
-    siteConfig: {
-      alwaysOn: true
-      linuxFxVersion: 'PYTHON|3.10'
-      ftpsState: 'Disabled'
-      appCommandLine: 'startup.sh'
-    }
-    httpsOnly: true
-  }
-  identity: {
-    type: 'SystemAssigned'
-  }
-
-```
-
----
-
-The Azure Database for PostgreSQL was also created using the following Bicep:
-
-```yml
-resource postgresServer 'Microsoft.DBforPostgreSQL/flexibleServers@2022-01-20-preview' = {
-  location: location
-  tags: tags
-  name: pgServerName
-  sku: {
-    name: 'Standard_B1ms'
-    tier: 'Burstable'
-  }
-  properties: {
-    version: '12'
-    administratorLogin: 'postgresadmin'
-    administratorLoginPassword: databasePassword
-    storage: {
-      storageSizeGB: 128
-    }
-    backup: {
-      backupRetentionDays: 7
-      geoRedundantBackup: 'Disabled'
-    }
-    network: {
-      delegatedSubnetResourceId: virtualNetwork::databaseSubnet.id
-      privateDnsZoneArmResourceId: privateDnsZone.id
-    }
-    highAvailability: {
-      mode: 'Disabled'
-    }
-    maintenanceWindow: {
-      customWindow: 'Disabled'
-      dayOfWeek: 0
-      startHour: 0
-      startMinute: 0
-    }
-  }
-
-  dependsOn: [
-    privateDnsZoneLink
-  ]
-}
-```
-
-### 3. Deployed the application
-
-The `azd up` command also deployed the sample application code to the provisioned Azure resources. The Developer CLI understands how to deploy different parts of your application code to different services in Azure using the `azure.yaml` file at the root of the project. The `azure.yaml` file specifies the app source code location, the type of app, and the Azure Service that should host that app. 
-
-Consider the following `azure.yaml` file. These configurations tell the Azure Developer CLI that the Python code that lives at the root of the project should be deployed to the created App Service.
-
-### [Flask](#tab/flask)
-
-```yml
-name: flask-postgresql-sample-app
-metadata:
-  template: flask-postgresql-sample-app@0.0.1-beta
-services:
-  web:
-    project: .
-    language: py
-    host: appservice
-```
-
-### [Django](#tab/django)
-
-```yml
-name: django-postgresql-sample-app
-metadata:
-  template: django-postgresql-sample-app@0.0.1-beta
-services:
-  web:
-    project: .
-    language: py
-    host: appservice
-```
-
----
-
-## Remove the resources
-
-Once you are finished experimenting with your sample application, you can run the `azd down` command to remove the app from Azure. Removing resources helps to avoid unintended costs or unused services in your Azure subscription.
-
-```bash
-azd down
-```
-
-:::zone-end
-
 ## Frequently asked questions
 
 - [How much does this setup cost?](#how-much-does-this-setup-cost)
diff --git a/articles/zone-pivot-groups.yml b/articles/zone-pivot-groups.yml
@@ -2563,15 +2563,6 @@ groups:
     title: Microsoft Graph PowerShell
   - id: ms-graph
     title: Microsoft Graph
-# Owner:
-- id: deploy-python-web-app-postgresql
-  title: Workflows
-  prompt: Choose your path
-  pivots:
-  - id: deploy-portal
-    title: Azure portal
-  - id: deploy-azd
-    title: Azure Developer CLI
 # Owner: daknappe (Azure Virtual Desktop)
 - id: azure-virtual-desktop-host-pool-types
   title: Azure Virtual Desktop host pool management type
