Resolve comments

Author: RichardChen820

articles/azure-app-configuration/media/quickstarts/kubernetes-provider-app-launch-after.png

@@ -34,12 +34,14 @@ In this quickstart, you incorporate Azure App Configuration Kubernetes Provider
 ## Create an application running in AKS
 In this section, it creates an ASP.NET Core web application that consumes environment variables as configuration and run it in Azure Kubernetes Service. This section has nothing to do with Azure App Configuration or Azure App Configuration Kubernetes Provider, it just for demonstrating the end-to-end usage scenario of Azure App Configuration Kubernetes Provider later. If you already have an application that is consuming environment variables in Kubernetes, you can just skip this section and go to [Use App Configuration Kubernetes Provider](#use-app-configuration-kubernetes-provider). 
 ### Create an application
-1. Use the .NET Core command-line interface (CLI) to create a new ASP.NET Core web app project. Run the following command to create an ASP.NET Core web app in a new MyWebApp folder:
+1. Use the .NET Core command-line interface (CLI) and run the following command to create a new ASP.NET Core web app project in a new MyWebApp folder:
+   
     ``` dotnetcli
     dotnet new webapp --output MyWebApp --framework net6.0
     ```
 
 1. Open *Index.cshtml* in the Pages directory, and update the content with the following code.
+   
     ``` html
     @page
     @model IndexModel
@@ -59,33 +61,39 @@ In this section, it creates an ASP.NET Core web application that consumes enviro
         <h1 class="display-4">@Configuration.GetSection("Settings")["Message"]</h1>
     </div>
     ```
+
 ### Containerize the application 
 1. Run the [dotnet publish](/dotnet/core/tools/dotnet-publish) command to build the app in release mode and create the assets in the published folder.
+   
     ``` dotnetcli
     dotnet publish -c Release -o published
     ```
+
 1. Create a file named *Dockerfile* in the directory containing your .csproj file, open it in a text editor, and enter the following content. A Dockerfile is a text file that doesn't have an extension and that is used to create a container image.
+
     ``` dockerfile
     FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime
     WORKDIR /app
     COPY published/ ./
     ENTRYPOINT ["dotnet", "MyWebApp.dll"]
     ```
-1. Build the container by running the following command.
+
+1. Build a container image named *aspnetapp* by running the following command.
+
    ``` docker
    docker build --tag aspnetapp .
    ```
 
-### Push the image to the registry
-1. Run the [az acr login](/cli/azure/acr#az-acr-login) command to log in to the registry.
+### Push the image to Azure Container Registry
+1. Run the [az acr login](/cli/azure/acr#az-acr-login) command to login your container registry. The following example login a registry named *myregistry*. Replace the registry name with yours.
 
     ```azurecli
     az acr login --name myregistry
     ```
 
     The command returns `Login Succeeded` once login is successful.
 
-1. Use [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) to tag the image appropriate details.
+1. Use [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) to create a tag *myregistry.azurecr.io/aspnetapp:v1* for the image *aspnetapp*.
 
     ```docker
     docker tag aspnetapp myregistry.azurecr.io/aspnetapp:v1
@@ -94,197 +102,198 @@ In this section, it creates an ASP.NET Core web application that consumes enviro
     > [!TIP]
     > To review the list of your existing docker images and tags, run `docker image ls`. In this scenario, you should see at least two images: `aspnetapp` and `myregistry.azurecr.io/aspnetapp`.
 
-1. Use [docker push](https://docs.docker.com/engine/reference/commandline/push/) to push the image to the container registry. This example creates the *aspnetapp* repository in ACR containing the `aspnetapp` image. In the example below, replace the placeholders `<login-server`, `<image-name>` and `<tag>` by the ACR's log-in server value, the image name and the image tag.
-
-    Method:
-
-    ```docker
-    docker push <login-server>/<image-name>:<tag>
-    ```
-
-    Example:
+1. Use [docker push](https://docs.docker.com/engine/reference/commandline/push/) to upload the image to the container registry. For example, the following command pushes the image to a repository named *aspnetapp* with tag *v1* under the registry *myregistry*.
 
     ```docker
     docker push myregistry.azurecr.io/aspnetapp:v1
     ```
 
-### Deploy the application and browser it
+### Deploy and visit the application
 1.  Create an *AKS-AppConfiguration-Demo* directory in the root directory of your project.
 
-1. Create *deployment.yaml* in the *AKS-AppConfiguration-Demo* directory with the following YAML content. Replace the value of `template.spec.containers.image` with the image you created in the previous step.
+1. Add a *deployment.yaml* to the *AKS-AppConfiguration-Demo* directory with the following content to create a deployment. Replace the value of `template.spec.containers.image` with the image you created in the previous step.
+
     ``` yaml
     apiVersion: apps/v1
     kind: Deployment
     metadata:
-      name: demo-deployment
+      name: aspnetapp-demo
       labels:
-        app: configmap-demo-app
+        app: aspnetapp-demo
     spec:
       replicas: 1
       selector:
         matchLabels:
-          app: configmap-demo-app
+          app: aspnetapp-demo
       template:
         metadata:
           labels:
-            app: configmap-demo-app
+            app: aspnetapp-demo
         spec:
           containers:
-          - name: configmap-demo-app
+          - name: aspnetapp
             image: myregistry.azurecr.io/aspnetapp:v1
             ports:
             - containerPort: 80
             env:
             - name: Settings__Message
-              value: "Hello from the environment variable"
+              value: "Message from the local configuration"
             - name: Settings__FontColor
-              value: "Orange"
+              value: "Black"
     ```
-1. Create *service.yaml* in the *AKS-AppConfiguration-Demo* with the following YAML content. 
+
+1. Add a *service.yaml* to the *AKS-AppConfiguration-Demo* directory with the following content to create a LoadBalancer service. 
+ 
     ``` yaml
     apiVersion: v1
     kind: Service
     metadata:
-      name: configmap-demo-service
+      name: aspnetapp-demo-service
     spec:
       type: LoadBalancer
       ports:
       - port: 80
       selector:
-        app: configmap-demo-app
+        app: aspnetapp-demo
     ```
 
-1. Apply the YAML files to the AKS cluster
+1. Run the following command to deploy the application to the AKS cluster.
+
     ``` bash
-    kubectl create namespace quickstart-appconfig
-    kubectl apply -f ./AKS-AppConfiguration-Demo -n quickstart-appconfig
+    kubectl create namespace appconfig-demo
+    kubectl apply -f ./AKS-AppConfiguration-Demo -n appconfig-demo
     ```
 
 1. Run the following command and get the External IP that exposed by the LoadBalancer service.
+   
     ``` bash
-    kubectl get service configmap-demo-service -n quickstart-appconfig
+    kubectl get service configmap-demo-service -n appconfig-demo
     ```
 
-1. Open a browser window, use the External IP of the service you get in previous step to visit the app. Your browser should display a page similar to the image below.
+1. Open a browser window, and navigate to the IP address obtained in the previous step. The web page looks like this:
 
     ![Kubernetes Provider before using configMap ](./media/quickstarts/kubernetes-provider-app-launch-before.png)
 
 ## Use App Configuration Kubernetes Provider
-### Configure the Azure App Configuration store
+Now that you have an application running in AKS, you will deploy the App Configuration Kubernetes Provider to your AKS cluster running as a Kubernetes controller. The provider will retrieve data from your App Configuration store and create a ConfigMap, which is consumable as environment variables by your application.
+### Setup the Azure App Configuration store
 1. Add following key-values to the App Configuration store and leave **Label** and **Content Type** with their default values. For more information about how to add key-values to a store using the Azure portal or the CLI, go to [Create a key-value](./quickstart-azure-app-configuration-create.md#create-a-key-value).
 
     |**Key**|**Value**|
     |---|---|
     |Settings__FontColor|*Green*|
     |Settings__Message|*Hello from Azure App Configuration*|
-
-    > [!TIP]
-    > This step adds the key-values to Azure App Configuration that is supposed to be consumed by the application. We're just using application `MyWebApp` as an example. If you are using your own application, you can add the key-values that are required by your application accordingly. 
     
-1. Enable System Assigned Managed Identity of AKS NodePool
-   
-    Go to the corresponding Virtual Machine Scale Sets resource of AKS, and enable system-assigned managed identity on the Virtual Machine Scale Sets by following this [doc](/azure/active-directory/managed-identities-azure-resources/qs-configure-portal-windows-vmss#enable-system-assigned-managed-identity-on-an-existing-virtual-machine-scale-set).
+1. [Enabling the system-assigned managed identity on the Virtual Machine Scale Sets of your AKS cluster](/azure/active-directory/managed-identities-azure-resources/qs-configure-portal-windows-vmss#enable-system-assigned-managed-identity-on-an-existing-virtual-machine-scale-set). This allows the App Configuration Kubernetes Provider to use the managed identity to connect to your App Configuration store.
 
-1. Assign Data Reader role to the System Assigned Managed Identity 
-   
-    Once the system-assigned managed identity has been enabled, you need to grant it read access to Azure AppConfiguration. You can do it by following the instructions in this [doc](/azure/azure-app-configuration/howto-integrate-azure-managed-service-identity?tabs=core5x&pivots=framework-dotnet#grant-access-to-app-configuration).
+1. Grant read access to your App Configuration store by [assigning the managed identity the App Configuration Data Reader role](/azure/azure-app-configuration/howto-integrate-azure-managed-service-identity?tabs=core5x&pivots=framework-dotnet#grant-access-to-app-configuration).
 
 ### Install App Configuration Kubernetes Provider to AKS cluster
-1. Get the credential to manage your AKS cluster, replace the `name` and `resource-group` parameters with yours:
+1. Run the following command to get access credentials for your AKS cluster. Replace the value of the `name` and `resource-group` parameters with your AKS instance:
+   
     ```bash
-    az aks get-credentials --name my_aks --resource-group my_aks_resource_group
+    az aks get-credentials --name <your-aks-instance-name> --resource-group <your-aks-resource-group>
     ```
 
 1. Install Azure App Configuration Kubernetes Provider to your AKS cluster using `helm`:
+   
     ``` bash
     helm install azureappconfiguration.kubernetesprovider \
-    oci://mcr.microsoft.com/azure-app-configuration/helmchart/kubernetes-provider \
-    --version 1.0.0-preview --namespace azappconfig-system --create-namespace
+         oci://mcr.microsoft.com/azure-app-configuration/helmchart/kubernetes-provider \
+         --version 1.0.0-preview \
+         --namespace azappconfig-system \
+         --create-namespace
     ```
 
-1. Create *appConfigurationProvider.yaml* with the following YAML content. Replace the value of the `endpoint` field with the endpoint of your Azure AppConfiguration store.
+1. Add an *appConfigurationProvider.yaml* file to the *AKS-AppConfiguration-Demo* directory with the following content to create an `AzureAppConfigurationProvider` resource. `AzureAppConfigurationProvider` is a custom resource that defines how to retrieve key-values from an Azure App Configuration store.
+
+    Replace the value of the `endpoint` field with the endpoint of your Azure App Configuration store.
+   
     ``` yaml
     apiVersion: azconfig.io/v1beta1
     kind: AzureAppConfigurationProvider
     metadata:
       name: appconfigurationprovider-sample
     spec:
-      endpoint: https://myappconfig.azconfig.io
+      endpoint: <your-app-configuration-store-endpoint>
       target:
         configMapName: demo-configmap
     ```
 
-1.  Apply *appConfigurationProvider.yaml* to the AKS cluster.
-    ``` bash
-    kubectl apply -f ./AKS-AppConfiguration-Demo -n quickstart-appconfig
-    ```
-    If namespace does not exists, run the following command to create it first.
-    ``` bash
-    kubectl create namespace quickstart-appconfig
-    ```
-
-### Update application deployment
-1. Update the *deployment.yaml* to use the configMap `demo-configmap` as environment variable.
+2. Update the *deployment.yaml* in *AKS-AppConfiguration-Demo* directory to use the configMap `demo-configmap` as environment variable.
    
-   Replace the whole `env` section 
+    Replace the whole `env` section 
     ``` yaml
     env:
     - name: Settings__Message
       value: "Hello from the environment variable"
     - name: Settings__FontColor
       value: "Orange"
     ```
-    with:
+    with
     ``` yaml
     envFrom:
     - configMapRef:
         name: demo-configmap
     ```
 
-1. Apply the updated *deployment.yaml* to the AKS cluster.
+3. Run the following command to deploy the `AzureAppConfigurationProvider` resource.
+   
     ``` bash
-    kubectl apply -f ./deployment.yaml -n quickstart-appconfig
+    kubectl apply -f ./AKS-AppConfiguration-Demo -n appconfig-demo
     ```
 
-1. Refresh the browser, can see the page has been updated based on the configuration from App Configuration.
+4. Refresh the browser. The page shows updated content.
+
+    ![Kubernetes Provider after using configMap](./media/quickstarts/kubernetes-provider-app-launch-after.png)
 
-    ![Kubernetes Provider after using configMap ](./media/quickstarts/kubernetes-provider-app-launch-after.png)
+### Troubleshooting
+If you don't see your application picking up the data from your App Configuration store, run the following command to validate that the ConfigMap is created properly.
 
-### Validation and troubleshooting
-A configMap *demo-configmap* is supposed to be created in the *quickstart-appconfig* namespace by the Azure App Configuration Kubernetes Provider.
 ``` bash
-kubectl get configmap demo-configmap -n quickstart-appconfig
+kubectl get configmap demo-configmap -n appconfig-demo
 ```
 
-In addition to check the existence of target configMap, you can also check the synchronization status of AppConfigurationProvider, run the following command in your terminal. If the `phase` property in the `status` section of the output is `COMPLETE` , it means that the key-values have been successfully synced from Azure App Configuration. 
+If the ConfigMap is not created properly, run the following command to get the data retrieval status.
+
 ``` bash
-kubectl get AppConfigurationProvider appconfigurationprovider-sample -n quickstart-appconfig -o yaml
+kubectl get AzureAppConfigurationProvider appconfigurationprovider-sample -n appconfig-demo -o yaml
 ```
-> [!TIP]
-> If you see another status is displayed for `phase`, you are presumably confronting some issue. You can run the following command to check what happened with the provider.
-> ``` bash    
-> kubectl logs deployment/az-appconfig-k8s-provider -n azappconfig-system
-> ```   
->
 
-If you see the error message in log with information *RESPONSE 403: 403 Forbidden*, it means that the system-assigned managed identity of AKS node pool does not have the permission to access the App Configuration store. You need to grant the permission to the managed identity by following the instructions in this [doc](/azure/azure-app-configuration/howto-integrate-azure-managed-service-identity?tabs=core5x&pivots=framework-dotnet#grant-access-to-app-configuration). If you have assigned the permission, you can wait for up to 15 minutes for the permission to take effect.
+If the Azure App Configuration Kubernetes Provider retrieved data from your App Configuration store successfully, the `phase` property under the status section of the output should be `COMPLETE`, as shown in the following example.
+
+![Kubernetes Provider get provider status](./media/quickstarts/kubernetes-provider-get-provider-status.png)
+
+If the phase is not `COMPLETE`, the data is not downloaded from your App Configuration store properly. Run the following command to show the logs of the Azure App Configuration Kubernetes Provider.
+
+``` bash    
+kubectl logs deployment/az-appconfig-k8s-provider -n azappconfig-system
+```   
+
+Use the logs for further troubleshooting. For example, if you see requests to your App Configuration store are responded with *RESPONSE 403: 403 Forbidden*, it may indicate the App Configuration Kubernetes Provider doesn't have the necessary permission to access your App Configuration store. Follow the instructions in [Setup the Azure App Configuration store](#setup-the-azure-app-configuration-store) to ensure the managed identity is enabled and it's assigned the proper permission.
 
 ## Clean up resources
-1. Remove the resources that have been deployed to AKS.
-    ``` bash
-    kubectl delete -f ./AKS-AppConfiguration-Demo -n quickstart-appconfig
-    kubectl delete namespace quickstart-appconfig
-    ```
-1. Uninstall the Azure App Configuration Kubernetes Provider.
-   ``` bash
-   helm uninstall azureappconfiguration.kubernetesprovider --namespace azappconfig-system
-   ```
 
-## Next steps
+[!INCLUDE[Azure App Configuration cleanup](../../includes/azure-app-configuration-cleanup.md)]
+
+Remove the resources that have been deployed to AKS.
+
+``` bash
+kubectl delete -f ./AKS-AppConfiguration-Demo -n appconfig-demo
+kubectl delete namespace appconfig-demo
+```
+
+Follow the steps below to uninstall the Azure App Configuration Kubernetes Provider from your AKS cluster.
+
+``` bash
+helm uninstall azureappconfiguration.kubernetesprovider --namespace azappconfig-system
+```
+
+## Summary
 
 In this quickstart, you:
 
 * Provisioned a new App Configuration store.
-* Connected to your App Configuration store in Kubernetes using the App Configuration Kubernetes Provider Operator.
-* Sync your App Configuration store's key-values to a ConfigMap.
+* Connected to your App Configuration store in Kubernetes using the App Configuration Kubernetes Provider controller.
+* Download your App Configuration store's key-values to a ConfigMap.
 * Displayed a web page in Kubernetes using the settings you configured in your App Configuration store.