When you want to implement blue-green deployment using Azure App Services, deployment slots is the way to go. You can create a staging slot to deploy the new version of your code, test it and swap with the production slot once ready to make the new version go live. Another main feature of App Service is configuration with app settings, who are environment variables set at the service level and injected to the application code. I have been using all of these for several projects over the years, but once we have started using IaC (especially Terraform), things became complicated as swap operations were messing up with the Terraform state.

Deployment Slots Explained

Instead, you should try to run the application with at least two or three instances, splitting your resource requirements across them, instead of one large instance. This will also help you when any upgrades are performed on the underlying VM instances, because the load will be redirected to the other available instances, preventing any downtime. Fortunately, you can easily achieve this by using the scale-out services provided by your App Service plan. (See Figure 3-34.) It is recommended that you set up automated scaling when handling increased resource or load requirements; setting up a minimum number of instances for the app up front can help mitigate a lot of basic issues.

It is difficult to take a one-size-fits-all approach when planning a deployment, so it will serve you well to understand these three main components. As of September 30, 2023, integrations for Microsoft OneDrive and Dropbox have been retired for Azure App Service and Azure Functions. Ensure any cascading deployments are disabled since these options no longer appear in the Azure portal. And I prefer not to mix both approaches, that’s why I ended up separating them and notifying the declarative stuff (the Terraform state) of the changes made by the imperative stuff (the swap with az cli).

• If you are deploying a new workload using an existing App Service plan, you should check the CPU and memory usage to make sure there is enough spare capacity to handle this deployment spike.
• If multiple URL paths are defined, App Service will wait for all the paths to confirm their status (success or failure) before the instance is made live.
• After the swap is performed, all settings applied to the staging or production slot will be applied to the code in the test slot (depending on which slot is selected).
• This can also help load-balance traffic between multiple geographies providing global load-balancing.

thoughts on “Azure App Service Deployment Slots Tips and Tricks”

Note that if you use separate branches (e.g., development vs. production), the production App Service remains on the older version until a merge or slot swap occurs. As I almost always do I have prepared a GitHub repository with a demo consisting of a simple ASP.NET web app, Terraform code and GitHub Actions for deployment. You can fork this repo and run the demo by yourself by following the instructions in the README file. When you scale out, it applies to all apps running on the App Service plan on all new instances. It can provide both performance benefits and cost savings—which can be maximized if the scaling occurs automatically. If CPU or memory utilization reaches or exceeds 90%, you should bring additional VM instances online so the overall load goes down.

Set this up if you notice that new app instances are causing timeouts, access failures, or other unexpected behavior when they come online. GitHub Actions makes it easy to build, test, and deploy code directly from GitHub to App Service. You should employ GitHub Actions if you are using GitHub as a deployment source to help automate code deployments with proper controls and change tracking. A build pipeline helps automate the process of compiling, testing, and packaging source code for deployment. The pipeline reads the source code data from the deployment source and performs a series of predefined steps to prepare it for deployment.

Always On is an App Service feature that ensures that VM instances are kept alive, even if there are no ingress requests or traffic to the VM instances for more than 20 minutes. This can help prevent the instance from going offline due to an idle timeout, thereby creating a cold-start situation that leads to delayed response times. Always On is disabled by default, but you easily enable it using the Azure Portal (see Figure 3-35), Azure PowerShell, or Azure CLI. Follow a similar approach to point a new build to staging to avoid unintended code activations.

Control SLOT-sticky configuration

This makes it important to use App Service settings and connection strings to store all the required database and unique app settings required for staging or production. If this configuration is stored in the application code, the staging or production application will write to the test database instances. The main issue with deployment slots and Terraform is that the swap operations are usually performed outside of Terraform. After a swap not only the deployed package changes from one slot to another, the swap impacts also all the configuration (including app settings), application stack, Docker image if you are using containers, etc. All of these properties are included in the Terraform state, so the the next apply after a swap will try to revert the changes, probably causing https://pin-upapp.in/en-in/ a mess. A deployment slot is a separate App Service resource hosted on the same App Service Plan.

Using the Azure CLI

(A hot code path is the one that take the longest to respond when handling a web request.) This can help you identify bottlenecks within an app and any dependencies. It also allows you to target development or troubleshooting efforts more appropriately. The Health Check feature works only when there are two or more VM instances running in the app.

After almost stopping using slots over the last few years, I have finally found an approach to make them work using Terraform and I’m happy to share it in this post. In the back end, the deployment slot is already live on worker instances, ready to receive connections. After the swap is performed, all settings applied to the staging or production slot will be applied to the code in the test slot (depending on which slot is selected).

You can use this to load code for testing; then, when testing is complete, you can swap the slot so the code moves to staging or production. This guide demonstrated setting up CI/CD with Azure App Service and using deployment slots to efficiently manage multiple environments. These techniques not only streamline deployments but also ensure seamless testing and safe rollbacks to maintain production stability. If you choose not to create a pull request, you can swap the deployment slots directly. Swapping exchanges the contents of the “dev” and production slots, enabling a quick rollback if needed. Running a production app with one VM instance creates a single point-of-failure.

The following sections step you through the process of setting up a different deployment source for the static web app you created earlier using the Azure Portal, Azure PowerShell, and Azure CLI. If you are following along, then make sure to adjust the web app name and variables as needed for each deployment. When you open the deployment slot overview, you’ll notice the “Traffic %” column. Once the CI/CD process completes for the “dev” slot, preview the changes by refreshing the slot’s URL. Changes committed to the development branch will only affect the “dev” slot until merged with the main branch or manually swapped. A common workflow involves committing code to a development branch, validating the changes via CI/CD, and then creating a pull request to merge into the main (production) branch.

Deployment mechanism

Setting up continuous deployment for production slots can result in code going live without proper controls. Deployment slots enable you to create multiple environments (such as staging, QA, UAT, or development) within a single Azure App Service. Testing new code in a staging slot prior to a production swap minimizes downtime and avoids performance issues like cold starts. Getting to the end of this post has been quite a ride, the writing went pretty smooth but once again I have probably spent way too much time on this demo.

But I’m happy with the result, I hope this provide one approach that everyone can use as a starting point to combine the benefits of deployment slots with Terraform. I have learned a ton doing this, as I had barely touched GitHub Actions before. There was also a few gotchas in Bash scripting, and I can’t remember the last time I built even the simplest webpage without a frontend framework… Thanks for reading, feel free to reach out to me if you need, and happy coding 🤓 If however for any reason you need to revert to the old behavior of swapping these settings then you can add the app setting WEBSITE_OVERRIDE_PRESERVE_DEFAULT_STICKY_SLOT_SETTINGS to every slot of the app and set its value to “0” or “false”. Deployment slots are not supported on the Free, Shared, or Basic tier plans; they are supported, however, on all plans from the Standard plan onward.

All scaling operations can be performed manually or automatically—if your App Service plan tier supports this. Autoscaling is available only in the Standard and Premium plans on the Dedicated tier and the ASE hosted on the Isolated tier. You can perform automatic scaling based on schedules and/or metric-based rules that trigger the scaling operation. A multi-region design can also help in routing requests to the closest datacenter based on the user’s region. This can be achieved using Azure Front Door or Azure Traffic Manager to manage all the ingress traffic and route it appropriately.

• I have been using all of these for several projects over the years, but once we have started using IaC (especially Terraform), things became complicated as swap operations were messing up with the Terraform state.
• This feature is disabled by default; however, it is recommended that you enable it.
• But I’m happy with the result, I hope this provide one approach that everyone can use as a starting point to combine the benefits of deployment slots with Terraform.
• After committing these changes, the updated repository synchronizes with the App Service.

Learn how to streamline your development workflow using Continuous Integration/Continuous Deployment (CI/CD) and deployment slots for Azure App Service. This guide covers best practices for automated deployments, managing multiple environments, and ensuring smooth rollbacks. After deployment, all instances should serve the new version, regardless of deployment slot. I would expect a professional cloud provider to deliver quality service, this is a rather disappointing experience and wastes our time. Per-app scaling enables you to scale each app in an App Service plan independently, meaning you can configure an app to run on only a certain number of instances.

After you do, define the path that the service should poll on a regular basis to identify unhealthy instances. Be sure the path you select is available on all instances and is critical for the functioning of the application. To avoid this scenario, it is recommended that you either build a stateless application or store the state information in a back-end service like a database or cache. Once that is in place, you can disable the ARR Affinity setting (see Figure 3-36), which should improve app performance.

This can also help load-balance traffic between multiple geographies providing global load-balancing. However, if possible, incorporate this into the application design at the earliest stage possible. The Azure Portal has an option to monitor App Service quotas, which you can use to monitor an app’s file system usage. For example, you might monitor this to ensure that the web folder has a minimum of 1 GB of free disk space for faster application restarts and scale-outs. The following section steps you through the process of setting up Auto-Heal using the Azure Portal.

The following sections step you through the process of setting up deployment slots for your web app using the Azure Portal, Azure PowerShell, and the Azure CLI. After committing these changes, the updated repository synchronizes with the App Service. The production environment remains unchanged until you merge into the main branch or manually swap deployment slots. Thanks @ruslany for clear explanation, refer this Blog to learn how to warm up Azure Web App during deployment slots swap. You can mark those two app setting as “Slot Settings” which would make them remain with the slot during the swap. Or you can have them as “non-sticky” settings meaning that they would move with the site as it gets swapped between slots.