Merge pull request #275163 from maud-lv/ml-sc-deprecatedcommands

PMEds28 · web-flow · commit 8a64e2c5c3fb · 2024-05-13T10:58:12.000+01:00
Update deprecated commands
diff --git a/articles/service-connector/tutorial-django-webapp-postgres-cli.md b/articles/service-connector/tutorial-django-webapp-postgres-cli.md
@@ -7,36 +7,17 @@ author: maud-lv
 ms.author: malev
 ms.service: service-connector
 ms.topic: tutorial
-ms.date: 11/22/2023
-zone_pivot_groups: postgres-server-options
+ms.date: 05/13/2024
 ---
 # Tutorial: Using Service Connector to build a Django app with Postgres on Azure App Service
 
 > [!NOTE]
-> You are using Service Connector that makes it easier to connect your web app to database service in this tutorial. The tutorial here is a modification of the [App Service tutorial](../app-service/tutorial-python-postgresql-app.md) to use this feature so you will see similarities. Look into section [Configure environment variables to connect the database](#configure-environment-variables-to-connect-the-database) in this tutorial to see where Service Connector comes into play and simplifies the connection process given in the App Service tutorial.
+> In this tutorial, you use Service Connector that simplifies the process of connecting a web app to a database service. This tutorial is a modification of the [App Service tutorial](../app-service/tutorial-python-postgresql-app.md), so you may see some similarities. Look into section [Configure environment variables to connect the database](#configure-environment-variables-to-connect-the-database) to see where Service Connector comes into play and simplifies the connection process given in the App Service tutorial.
 
-::: zone pivot="postgres-single-server"
-
-This tutorial shows how to deploy a data-driven Python [Django](https://www.djangoproject.com/) web app to [Azure App Service](overview.md) and connect it to an Azure Database for a Postgres database. You can also try the PostgreSQL Flexible Server by selecting the option above. Flexible Server provides a simpler deployment mechanism and lower ongoing costs.
+This tutorial shows how to deploy a data-driven Python [Django](https://www.djangoproject.com/) web app to [Azure App Service](overview.md) and connect it to an [Azure Database for PostgreSQL Flexible server](../postgresql/flexible-server/index.yml) database.
 
 In this tutorial, you use the Azure CLI to complete the following tasks:
 
-> [!div class="checklist"]
-> * Set up your initial environment with Python and the Azure CLI
-> * Create an Azure Database for PostgreSQL database
-> * Deploy code to Azure App Service and connect to PostgreSQL
-> * Update your code and redeploy
-> * View diagnostic logs
-> * Manage the web app in the Azure portal
-
-:::zone-end
-
-::: zone pivot="postgres-flexible-server"
-
-This tutorial shows how to deploy a data-driven Python [Django](https://www.djangoproject.com/) web app to [Azure App Service](overview.md) and connect it to an [Azure Database for PostgreSQL Flexible server](../postgresql/flexible-server/index.yml) database. If you can't use PostgreSQL Flexible server, then select the Single Server option above.
-
-In this tutorial, you'll use the Azure CLI to complete the following tasks:
-
 > [!div class="checklist"]
 > * Set up your initial environment with Python and the Azure CLI
 > * Create an Azure Database for PostgreSQL Flexible server database
@@ -45,12 +26,6 @@ In this tutorial, you'll use the Azure CLI to complete the following tasks:
 > * View diagnostic logs
 > * Manage the web app in the Azure portal
 
-:::zone-end
-
-## Prerequisites
-
-* An Azure account with an active subscription. [Create an account for free](https://azure.microsoft.com/free/).
-
 ## Set up your initial environment
 
 1. Install [Python 3.8 or higher](https://www.python.org/downloads/). To check if your Python version is 3.8 or higher, run the following code in a terminal window:
@@ -95,26 +70,18 @@ Navigate into the following folder:
 cd serviceconnector-webapp-postgresql-django
 ```
 
-::: zone pivot="postgres-flexible-server"
-
 Use the flexible-server branch of the sample, which contains a few necessary changes, such as how the database server URL is set and adding `'OPTIONS': {'sslmode': 'require'}` to the Django database configuration as required by Azure PostgreSQL Flexible server.
 
 ```terminal
 git checkout flexible-server
 ```
 
-::: zone-end
-
 ### [Download](#tab/download)
 
 Visit [https://github.com/Azure-Samples/djangoapp](https://github.com/Azure-Samples/djangoapp).
 
-::: zone pivot="postgres-flexible-server"
-
 For Flexible server, select the branches control that says "master" and then select the **flexible-server** branch.
 
-::: zone-end
-
 Select **Code**, and then select **Download ZIP**.
 
 Unpack the ZIP file into a folder named *djangoapp*.
@@ -136,64 +103,6 @@ Having issues? [Let us know](https://aka.ms/DjangoCLITutorialHelp).
 
 ## Create Postgres database in Azure
 
-::: zone pivot="postgres-single-server"
-
-<!-- > [!NOTE]
-> Before you create an Azure Database for PostgreSQL server, check which [compute generation](../postgresql/concepts-pricing-tiers.md#compute-generations-and-vcores) is available in your region. -->
-
-1. Enable parameters caching with the Azure CLI so you don't need to provide those parameters with every command. (Cached values are saved in the *.azure* folder.)
-
-    ```azurecli
-    az config param-persist on 
-    ```
-
-1. Install the `db-up` extension for the Azure CLI:
-
-    ```azurecli
-    az extension add --name db-up
-    ```
-
-    If the `az` command isn't recognized, be sure you have the Azure CLI installed as described in [Set up your initial environment](#set-up-your-initial-environment).
-
-1. Create the Postgres database in Azure with the [`az postgres up`](/cli/azure/postgres#az-postgres-up) command:
-
-    ```azurecli
-    az postgres up --resource-group ServiceConnector-tutorial-rg --location eastus --sku-name B_Gen5_1 --server-name <postgres-server-name> --database-name pollsdb --admin-user <admin-username> --admin-password <admin-password> --ssl-enforcement Enabled
-    ```
-
-    Replace the following placeholder texts with your own data:
-
-    * **Replace** *`<postgres-server-name>`* with a name that's **unique across all Azure** (the server endpoint becomes `https://<postgres-server-name>.postgres.database.azure.com`). A good pattern is to use a combination of your company name and another unique value.
-
-    * For *`<admin-username>`* and *`<admin-password>`*, specify credentials to create an administrator user for this Postgres server. The admin username can't be *azure_superuser*, *azure_pg_admin*, *admin*, *administrator*, *root*, *guest*, or *public*. It can't start with *pg_*. The password must contain **8 to 128 characters** from three of the following categories: English uppercase letters, English lowercase letters, numbers (0 through 9), and non-alphanumeric characters (for example, *!*, *#*, *%*). The password can't contain a username.
-    * Don't use the `$` character in the username or password. You'll later create environment variables with these values where the `$` character has special meaning within the Linux container used to run Python apps.
-    * The `*B_Gen5_1*` (Basic, Gen5, 1 core) [pricing tier](../postgresql/concepts-pricing-tiers.md) used here is the least expensive. For production databases, omit the `--sku-name` argument to use the GP_Gen5_2 (General Purpose, Gen 5, 2 cores) tier instead.
-
-    This command performs the following actions, which may take a few minutes:
-
-    * Create a [resource group](../azure-resource-manager/management/overview.md#terminology) called `ServiceConnector-tutorial-rg`, if it doesn't already exist.
-    * Create a Postgres server named by the `--server-name` argument.
-    * Create an administrator account using the `--admin-user` and `--admin-password` arguments. You can omit these arguments to allow the command to generate unique credentials for you.
-    * Create a `pollsdb` database as named by the `--database-name` argument.
-    * Enable access from your local IP address.
-    * Enable access from Azure services.
-    * Create a database user with access to the `pollsdb` database.
-
-    You can do all the steps separately with other `az postgres` and `psql` commands, but `az postgres up` does all the steps together.
-
-    When the command completes, it outputs a JSON object that contains different connection strings for the database along with the server URL, a generated user name (such as "joyfulKoala@msdocs-djangodb-12345"), and a GUID password.
-
-    > [!IMPORTANT]
-    > Copy the user name and password to a temporary text file as you will need them later in this tutorial.
-
-    <!-- not all locations support az postgres up -->
-    > [!TIP]
-    > `-l <location-name>` can be set to any [Azure regions](https://azure.microsoft.com/global-infrastructure/regions/). You can get the regions available to your subscription with the [`az account list-locations`](/cli/azure/account#az-account-list-locations) command. For production apps, put your database and your app in the same location.
-
-::: zone-end
-
-::: zone pivot="postgres-flexible-server"
-
 1. Enable parameters caching with the Azure CLI so you don't need to provide those parameters with every command. (Cached values are saved in the *.azure* folder.)
 
     ```azurecli
@@ -227,8 +136,6 @@ Having issues? [Let us know](https://aka.ms/DjangoCLITutorialHelp).
 
 1. When the command completes, **copy the command's JSON output to a file** as you need values from the output later in this tutorial, specifically the host, username, and password, along with the database name.
 
-::: zone-end
-
 Having issues? [Let us know](https://aka.ms/DjangoCLITutorialHelp).
 
 ## Deploy the code to Azure App Service
@@ -237,36 +144,6 @@ In this section, you create app host in App Service app, connect this app to the
 
 ### Create the App Service app
 
-::: zone pivot="postgres-single-server"
-
-1. In the terminal, make sure you're in the *djangoapp* repository folder that contains the app code.
-
-1. Create an App Service app (the host process) with the [`az webapp up`](/cli/azure/webapp#az-webapp-up) command:
-
-    ```azurecli
-    az webapp up --resource-group ServiceConnector-tutorial-rg --location eastus --plan ServiceConnector-tutorial-plan --sku B1 --name <app-name>
-    ```
-    <!-- without --sku creates PremiumV2 plan -->
-
-    * For the `--location` argument, make sure you use the location that [Service Connector supports](concept-region-support.md).
-    * **Replace** *\<app-name>* with a unique name across all Azure (the server endpoint is `https://<app-name>.azurewebsites.net`). Allowed characters for *\<app-name>* are `A`-`Z`, `0`-`9`, and `-`. A good pattern is to use a combination of your company name and an app identifier.
-
-    This command performs the following actions, which may take a few minutes:
-
-    <!-- - Create the resource group if it doesn't exist. `--resource-group` is optional. -->
-    <!-- No it doesn't. az webapp up doesn't respect --resource-group -->
-
-    * Create the [resource group](../azure-resource-manager/management/overview.md#terminology) if it doesn't already exist. (In this command you use the same resource group in which you created the database earlier.)
-    * Create the [App Service plan](../app-service/overview-hosting-plans.md) *DjangoPostgres-tutorial-plan* in the Basic pricing tier (B1), if it doesn't exist. `--plan` and `--sku` are optional.
-    * Create the App Service app if it doesn't exist.
-    * Enable default logging for the app, if not already enabled.
-    * Upload the repository using ZIP deployment with build automation enabled.
-    * 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. Commands that come from CLI extensions, such as `az postgres up`, however, do not at present use the cache, which is why you needed to specify the resource group and location here with the initial use of `az webapp up`.
-
-::: zone-end
-
-::: zone pivot="postgres-flexible-server"
-
 1. In the terminal, make sure you're in the *djangoapp* repository folder that contains the app code.
 
 1. Switch to the sample app's `flexible-server` branch. This branch contains specific configuration needed for PostgreSQL Flexible server:
@@ -291,8 +168,6 @@ In this section, you create app host in App Service app, connect this app to the
     * Enable default logging for the app.
     * Upload the repository using ZIP deployment with build automation enabled.
 
-::: zone-end
-
 Upon successful deployment, the command generates JSON output like the following example:
 
 :::image type="content" source="../app-service/media/tutorial-python-postgresql-app/az-webapp-up-output.png" alt-text="Screenshot of the terminal, showing an example output for the az webapp up command." :::
@@ -307,21 +182,6 @@ The app code expects to find database information in four environment variables
 
 To set environment variables in App Service, create "app settings" with the following `az connection create` command.
 
-::: zone pivot="postgres-single-server"
-
-```azurecli
-az webapp connection create postgres --client-type django
-```
-
-The resource group, app name, db name are drawn from the cached values. You need to provide admin password of your postgres database during the execution of this command.
-
-* The command creates settings named "AZURE_POSTGRESQL_HOST", "AZURE_POSTGRESQL_NAME", "AZURE_POSTGRESQL_USER", "AZURE_POSTGRESQL_PASS" as expected by the app code.
-* If you forgot your admin credentials, the command would guide you to reset it.
-
-::: zone-end
-
-::: zone pivot="postgres-flexible-server"
-
 ```azurecli
 az webapp connection create postgres-flexible --client-type django
 ```
@@ -331,8 +191,6 @@ The resource group, app name, db name are drawn from the cached values. You need
 * The command creates settings named "AZURE_POSTGRESQL_HOST", "AZURE_POSTGRESQL_NAME", "AZURE_POSTGRESQL_USER", "AZURE_POSTGRESQL_PASS" as expected by the app code.
 * If you forgot your admin credentials, the command would guide you to reset it.
 
-::: zone-end
-
 > [!NOTE]
 > If you see the error message "The subscription is not registered to use Microsoft.ServiceLinker", please run `az provider register -n Microsoft.ServiceLinker` to register the Service Connector resource provider and run the connection command again.
 
@@ -391,7 +249,7 @@ Having issues? Refer first to the [Troubleshooting guide](../app-service/configu
 
 ## Clean up resources
 
-If you'd like to keep the app or continue to additional tutorials, skip ahead to [Next steps](#next-steps). Otherwise, to avoid incurring ongoing charges, delete the resource group created for this tutorial:
+If you'd like to keep the app or continue to more tutorials, skip ahead to [Next steps](#next-step). Otherwise, to avoid incurring ongoing charges, delete the resource group created for this tutorial:
 
 ```azurecli
 az group delete --name ServiceConnector-tutorial-rg --no-wait
@@ -403,9 +261,7 @@ Deleting all the resources can take some time. The `--no-wait` argument allows t
 
 Having issues? [Let us know](https://aka.ms/DjangoCLITutorialHelp).
 
-## Next steps
-
-Follow the tutorials listed below to learn more about Service Connector.
+## Next step
 
 > [!div class="nextstepaction"]
 > [Learn about Service Connector concepts](./concept-service-connector-internals.md)
diff --git a/articles/service-connector/tutorial-java-spring-confluent-kafka.md b/articles/service-connector/tutorial-java-spring-confluent-kafka.md
@@ -98,7 +98,7 @@ Create an instance of Azure Spring Apps by following [the Azure Spring Apps quic
 1. Create the app with a public endpoint assigned. If you selected Java version 11 when generating the Spring Cloud project, include the `--runtime-version=Java_11` switch.
 
     ```azurecli
-    az spring-cloud app create -n hellospring -s <service-instance-name> -g <your-resource-group-name> --assign-endpoint true
+    az spring app create -n hellospring -s <service-instance-name> -g <your-resource-group-name> --assign-endpoint true
     ```
 
 ## Create a service connection using Service Connector
@@ -108,7 +108,7 @@ Create an instance of Azure Spring Apps by following [the Azure Spring Apps quic
 Run the following command to connect your Apache Kafka on Confluent Cloud to your spring cloud app.
 
 ```azurecli
-az spring-cloud connection create confluent-cloud -g <your-spring-cloud-resource-group> --service <your-spring-cloud-service> --app <your-spring-cloud-app> --deployment <your-spring-cloud-deployment> --bootstrap-server <kafka-bootstrap-server-url> --kafka-key <cluster-api-key> --kafka-secret <cluster-api-secret> --schema-registry <kafka-schema-registry-endpoint> --schema-key <registry-api-key> --schema-secret <registry-api-secret>
+az spring connection create confluent-cloud -g <your-spring-cloud-resource-group> --service <your-spring-cloud-service> --app <your-spring-cloud-app> --deployment <your-spring-cloud-deployment> --bootstrap-server <kafka-bootstrap-server-url> --kafka-key <cluster-api-key> --kafka-secret <cluster-api-secret> --schema-registry <kafka-schema-registry-endpoint> --schema-key <registry-api-key> --schema-secret <registry-api-secret>
 ```
 
 Replace the following placeholder texts with your own data:
@@ -147,7 +147,7 @@ Select **Review + Create** to review the connection settings. Then select **Crea
 Run the following command to upload the JAR file (`build/libs/java-springboot-0.0.1-SNAPSHOT.jar`) to your Spring Cloud app.
 
 ```azurecli
-az spring-cloud app deploy -n hellospring -s <service-instance-name> -g <your-resource-group-name>  --artifact-path build/libs/java-springboot-0.0.1-SNAPSHOT.jar
+az spring app deploy -n hellospring -s <service-instance-name> -g <your-resource-group-name>  --artifact-path build/libs/java-springboot-0.0.1-SNAPSHOT.jar
 ```
 
 ## Validate the Kafka data ingestion
