edits

diberry · diberry · commit e198ebf6be91 · 2024-08-27T14:20:19.000-07:00
diff --git a/articles/static-web-apps/publish-bicep.md b/articles/static-web-apps/publish-bicep.md
@@ -12,30 +12,25 @@ ms.author: cshoe
 
 # Deploy Azure Static Web Apps with Bicep
 
-Use a Bicep file to create your Azure Static Web app to Azure. Bicep is a domain-specific language (DSL) that uses declarative syntax to define and create Azure resources repeatedly in a consistent manner.
+Use a Bicep file to create your Azure Static Web app to Azure. Bicep provides a declarative syntax to define and create Azure resources repeatedly in a consistent manner, which can be automated and repeated.
+
+Your creation process should include all the resources in your application. This article details how to create the resource group that holds all the resources for your application, the Azure Static Web Apps resource, which contains your statically generated client application such as React, Vue, or Svelte, and the linked Azure Functions backend.
 
-To deploy your static web app, you need to: 
-* Create resources with Bicep
-* Deploy your source code. Use one of the following tools to deploy your app:
-    * [Azure Developer CLI](/azure/developer/azure-developer-cli)
-    * [Static Web Apps CLI](https://github.com/Azure/static-web-apps-cli)
-    * [GitHub Actions](https://docs.github.com/actions)
- 
 ## Types of resource creation
 
  Bicep is one of several types of resource creation. These types include:
 
-* [Azure Resource Management](/azure/azure-resource-manager/) (ARM): implement infrastructure as code for your Azure solutions, use Azure Resource Manager templates (ARM templates). The template is a JavaScript Object Notation (JSON) file that defines the infrastructure and configuration for your project. This older style is still in use but generally updated to Bicep or Azure Verified Modules. 
+* [Azure Resource Management](/azure/azure-resource-manager/) (ARM): implement infrastructure as code for your Azure solutions, use Azure Resource Manager templates (ARM templates). The template is a JavaScript Object Notation (JSON) file that defines the infrastructure and configuration for your project. This older style is still in use but updated to Bicep or Azure Verified Modules. 
 * [Bicep](/azure/azure-resource-manager/Bicep/): Bicep is a domain-specific language (DSL) that uses declarative syntax to deploy Azure resources. In a Bicep file, you define the infrastructure you want to deploy to Azure, and then use that file throughout the development lifecycle to repeatedly deploy your infrastructure. Your resources are deployed in a consistent manner.
 * [Azure verified modules (AVM)](https://azure.github.io/Azure-Verified-Modules): These modules represent the only standard from Microsoft for Bicep modules in the [Bicep Public Registry](https://github.com/Azure/bicep-registry-modules/tree/main/avm). Use AVM when possible because it consolidates and set the standards for what a good Infrastructure-as-Code module looks like.
-* [Azure CLI](/cli/azure/)/[PowerShell](/powershell): These command line apps allow you to create resources. They have generally been superceded by Bicep and AVM but are still used for minor or quick fixes while the larger Bicep update may be more time-consuming.
+* [Azure CLI](/cli/azure/)/[PowerShell](/powershell): These command line apps allow you to create resources. They have generally been superseded by Bicep and AVM but are still used for minor or quick fixes while the larger Bicep update may be more time-consuming. Learn to [create resources with the Azure CLI and a Bicep file](/azure/azure-resource-manager/bicep/deploy-cli#deploy-local-bicep-file). 
 * [Azure portal](https://portal.azure.com/): Azure portal is a web-based visual interface for resource creation and configuration.
 
 Creation and configuration can be done across all the tools listed above.  
 
 ## Bicep by example
 
-The Bicep examples in this article use [Azure Verified Modules (AVM)](https://azure.github.io/Azure-Verified-Modules/) when possible and [Bicep](/azure/azure-resource-manager/Bicep/) when AVM isn't available. You'll be able to recognize AVM because the referenced module includes `avm/res` such as `br/public:avm/res/web/static-site:0.3.0`.
+The bicep examples in this article use [Azure Verified Modules (AVM)](https://azure.github.io/Azure-Verified-Modules/) when possible and [bicep](/azure/azure-resource-manager/bicep/) when AVM isn't available. AVM modules are recognizable because they reference modules that include `avm/res`, such as `br/public:avm/res/web/static-site:0.3.0`.
 
 ```Bicep
 module swa 'br/public:avm/res/web/static-site:0.3.0' = {
@@ -50,24 +45,19 @@ module swa 'br/public:avm/res/web/static-site:0.3.0' = {
 }
 ```
 
-AVM allows you to adopt Bicep code, which has been built and is maintained by professional engineers fluent in Bicep. These modules aren't only supported and maintained, they're opinionated about what proper Bicep files look like.
+AVM allows you to use managed Bicep code, which has been built and is maintained by professional engineers fluent in Bicep. These modules aren't only supported and maintained, they're opinionated about what proper Bicep files look like.
 
 Due to the work involved in owning and maintaining the AVM files, it takes time to specify the module, determine best practices, and find the appropriate owner/maintainer. For this reason, the module you need may not be available at this time. 
 
 ## Prerequisites
 
-- [Bicep](../azure-resource-manager/Bicep/install.md)
-- Optional, [Visual Studio Code extension for Bicep](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-Bicep). This extension is used to immediately run your Bicep file, which creates your resources.
+- [Bicep tools](../azure-resource-manager/Bicep/install.md)
+- [Visual Studio Code extension for Bicep](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-bicep): An optional extension that creates resources for you by running your Bicep file.
 
 ## Create a static web app resource
 
-Create a `main.Bicep` file with the Bicep code below to:
+Create a file named `main.bicep` file and paste in the following code:
 
-* Create a unique string, `resourceToken`. 
-* Create tags for the resources. Tags are filterable in the Azure portal. 
-* Create a unique resource group.
-* Create a Static web app.
-    
 ```Bicep
 targetScope = 'subscription'
 
@@ -77,9 +67,6 @@ param location string ='eastus2'
 @description('Random string to make resource names unique')
 var resourceToken = uniqueString(subscription().subscriptionId, location)
 
-@description('Tags to be added to all resources')
-var tags = { 'docs-Bicep-example-swa': resourceToken }
-
 @description('Create a resource group')
 resource rg 'Microsoft.Resources/resourceGroups@2024-03-01' = {
   name: 'rg-swa-app-${resourceToken}'
@@ -95,7 +82,6 @@ module swa 'br/public:avm/res/web/static-site:0.3.0' = {
     name: 'swa-${resourceToken}'
     location: location
     sku: 'Free'
-    tags: union(tags, { 'service-name': 'client' })
   }
 }
 
@@ -106,17 +92,23 @@ output endpoint string = swa.outputs.defaultHostname
 output staticWebAppName string = swa.outputs.name
 ```
 
-Save the values of the output variables. You'll need these to configure the resources.
+This file creates the following resources for you:
+* An application name as the `resourceToken` value
+* Tags associated with your app to help you find and filter resources in the Azure portal
+* A resource group for this application
+* A static web app
 
-## Create a static web app with a linked backend function app
+Save the values of the output variables to a text editor. You'll need these to configure the resources. The next step is to include a linked backend Azure Functions app in the next section.
 
-To create a static web app with a linked backend function app, you need to use a standard plan for your static web app and complete the following steps.
+## Link a Functions app
 
-* [Create the Azure Function app](/azure/azure-functions/functions-create-first-function-Bicep). You need the `resourceId` for the Function app, which looks like: `/subscriptions/<SUBSCRIPTION-ID>/resourcegroups/<RESOURCE-GROUP-NAME>/providers/Microsoft.Web/sites/<FUNCTION-APP-NAME>`.
-* Create the static web app using the [Bicep in the previous section](#create-a-static-web-app-resource).
-* Link the static web app to the function app.
+To link a Functions app for your backend, use the Static Web Apps standard plan for your web app and complete the following steps.
 
-Create a `config.Bicep` file to link the static web app to the function app. 
+To create the Azure Function app, follow the instructions provided in the Create the Azure Function app guide. You'll need the resourceId for the Function app, which looks like: /subscriptions/<SUBSCRIPTION-ID>/resourcegroups/<RESOURCE-GROUP-NAME>/providers/Microsoft.Web/sites/<FUNCTION-APP-NAME>.
+
+Next, create the static web app using the Bicep template provided in the previous section. This sets up the necessary resources for your static web app. Finally, link the static web app to the function app to enable seamless integration between your front-end and back-end services.
+
+Create a file named `config.bicep` file and paste in the following code: 
 
 ```Bicep
 targetScope = 'resourceGroup'
@@ -154,17 +146,44 @@ resource linkedStaticWebAppBackend 'Microsoft.Web/staticSites/linkedBackends@202
 }
 ```
 
+This file handles the following tasks:
+
+* Creates variables to use in resource configuration.
+* Create a reference to the existing static web app.
+* Create a reference string for the existing functions app.
+* Configure the static web app to link to the functions app.
+
 ## Deployment
 
-After your resources are created, you can deploy your application to the hosting environment. The following descriptions show you how to work both locally and deploy though GitHub Actions:
+Deploy your source code with one of the following tools to deploy your app:
+    * [Azure Developer CLI (Recommended)](/azure/developer/azure-developer-cli)
+    * [Static Web Apps CLI](https://github.com/Azure/static-web-apps-cli)
+    * [GitHub Action](https://docs.github.com/actions)
+    * [Azure DevOps](/azure/devops/pipelines/overview-azure)
 
 * **Local development environment**: Use [Azure Developer CLI](/azure/developer/azure-developer-cli) to deploy from your local machine. When running locally, you define your deployment in an `azure.yml` file. This file includes hooks that plug into the resource creation process at any point to help you during deployment, especially when different parts of your app need to know about each other at build time.
 
 * **Production environment**: The ability to deploy from a GitHub Actions workflow file is a built-in feature when you create your static web app. Once the file is in your repository, you can edit the file as needed. Deployment from [other source code providers](external-providers.md) is also supported.
 
 To learn more from a full end-to-end application that includes resource creation and application deployment, see [Serverless AI Chat with RAG using LangChain.js](https://github.com/Azure-Samples/serverless-chat-langchainjs).
 
+## Speeding up deployments with Azure Developer CLI
+
+Azure Developer CLI (`azd`) uses Bicep files along with deployment configurations to create and provision your application. Since version 1.4, azd checks the Bicep against cloud resources to understand if the underlying infrastructure as code (IaC) state requires updates. If the state hasn't changed, creation and configuration is skipped. Learn more about this [performance improvement](
+https://devblogs.microsoft.com/azure-sdk/azure-developer-cli-azd-october-2023-release/#azd-provision-is-now-faster-when-there-are-no-infrastructure-changes
+).
+
+## Azure samples 
+
+The following samples create and deploy Azure Static Web apps with Azure Developer CLI:
+
+* 
+
 ## Related content
 
 * [Awesome AZD](https://azure.github.io/awesome-azd/?tags=swa)
 * [Public Bicep Registry](https://github.com/Azure/bicep-registry-modules)
+* [Azure Developer CLI](/azure/developer/azure-developer-cli)
+* [Static Web Apps CLI](https://github.com/Azure/static-web-apps-cli)
+* [GitHub Actions](https://docs.github.com/actions)
+ 
