How to Deploy a .NET isolated Azure Function in One-Click using Zip Deploy
Tags: arm, azure, deployment, devops
Published: 2024-04-15 13:43:03

---
title: How to Deploy a .NET isolated Azure Function in One-Click using Zip Deploy
published: true
date: 2024-04-11 15:56:00 UTC
tags: arm,azure,deployment,devops
canonical_url: https://www.frankysnotes.com/2024/04/how-to-deploy-net-isolated-azure.html
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/60v9twm45k1ybl3jk5ol.jpg
---

In this post, I will share a few things that we need our attention when deploying a .NET isolated Azure Function from GitHub to Azure using the Zip Deploy method. This method is great for fast deployment and when your artefacts are zipped in a package.

> Note The complete code for this post is available on [GitHub](https://github.com/FBoucher/ZipDeploy-AzFunc)

## Understanding Zip Push/Zip Deploy

Zip Push allows us to deploy a compressed package, such as a zip file, directly to Azure. It could be part of a continuous integration and continuous deployment (CI-CD) or like in this example it could replace it. This approach is particularly useful when you want to ensure your artifacts remain unchanged across different environments or when aiming for the fastest deployment experience for users.

While CI-CD is excellent for keeping your code up-to-date, zip deployment offers the advantage of speed and consistency. It eliminates the need for compilation, leading to quicker uploads and deployments.

## Preparing Your Package

It’s crucial to package with all necessary dependencies the code required. There is no operation to fetch any external packages during the deployment, the zip file will be decompressed and that's it. The best way to ensure you have everything you need is to publish your code, to a folder and then go in that folder and zip all the files.

```
dotnet publish -c Release -o ./out
```

Don't zip the folder, it won't work as expected.

[![Don't zip the publish folder it won't works](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/r9we0qwy4ubfwwodjuao.png)](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/r9we0qwy4ubfwwodjuao.png)

You need to go inside the folder and select all the files and zip them to create your deployment artefact.

[![From in the publish folder zip all files](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kqdng94s6s1s5lveik34.png)](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kqdng94s6s1s5lveik34.png)

The next step is to make your artefact available online. There are many ways, but for this post we are using GitHub Realease. From the GitHub repository, create a new release, upload the zipped file created earlier and publish it. Note the URL of zipped files from the release.

## Preparing The ARM Template

For this one-click deployment, we need an Azure Resource Manager (ARM) template. This is a document that describes the resources that we want to deploy to Azure. To deploy the zipped file into the Azure Function there are two particularities that required our attention.

Here the sections of the template.

```
[...]
"resources": [
    {
        "apiVersion": "2022-03-01",
        "name": "[variables('funcAppName')]",
        "type": "Microsoft.Web/sites",
        "kind": "functionapp",
        "location": "[resourceGroup().location]",
        "properties": {
            "name": "[variables('funcAppName')]",
            "siteConfig": {
                "appSettings": [
                    {
                        "name": "FUNCTIONS_WORKER_RUNTIME",
                        "value": "dotnet-isolated"
                    },
                    {
                        "name": "WEBSITE_RUN_FROM_PACKAGE",
                        "value": "1"
                    },
                    [...]

```

Here we define an Windows Azure Function and the `WEBSITE_RUN_FROM_PACKAGE` needs to be set to `1`. The `WEBSITE_RUN_FROM_PACKAGE` is the key that tells Azure to use the zip file as the deployment artefact.

Then to specify where the zip file is located we need to add an extension to the Azure Function.

```
    {
      "type": "Microsoft.Web/sites/extensions",
      "apiVersion": "2021-02-01",
      "name": "[format('{0}/ZipDeploy', variables('funcAppName'))]",
      "properties": {
        "packageUri": "https://github.com/FBoucher/ZipDeploy-AzFunc/releases/download/v1/ZipDeploy-package-v1.zip",
        "appOffline": true
      },
      "dependsOn": [
        "[concat('Microsoft.Web/sites/', variables('funcAppName'))]"
      ]
    }

```

The `packageUri` property is the URL of the zipped file from the GitHub release. Note the `dependsOn` property that ensures the Azure Function is created before the extension is added. The complete ARM template is available in the [GitHub](https://github.com/FBoucher/ZipDeploy-AzFunc) repository.

## One-click Deployment

When you have your artefact and the ARM template uploaded to your GitHub repository, you can create a one-click deployment button. This button will take the user to the Azure portal and pre-fill the deployment form with the information from the ARM template. Here is an example of the button for markdown.

```
[![Deploy to Azure](https://aka.ms/deploytoazurebutton)](https://portal.azure.com/#create/Microsoft.Template/uri/https%3A%2F%2Fraw.githubusercontent.com%2FFBoucher%2FZipDeploy-AzFunc%2Fmain%2Fdeployment%2Fazuredeploy.json)

```

The has three parts, the first is the image that will be displayed on the button, the second is the link to the Azure portal and the third is the URL of the ARM template. The URL of the ARM template is the **raw URL** of the file in the GitHub repository, and it needs to be URL encoded. The URL encoding can be done using a tool like [URL Encode/Decode](https://www.urlencoder.org/).

[![Button on GitHub Repo page](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fg124yva2mfmmm7g3k5w.png)](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fg124yva2mfmmm7g3k5w.png)

## Final Thoughts

Zip deployment is a powerful tool in your Azure arsenal by itself of part of a more complex CI-CD pipeline. It's a great way to make it easier for people to deploy your solution in their Azure subscription without having to clone/ fork the repository.

## Video version

If you prefer, there is also have a video version of this post.

{% youtube LHJTUvjw9po %}

### References

- [Zip deployment for Azure Functions](https://docs.microsoft.com/en-us/azure/azure-functions/deployment-zip-push?WT.mc_id=dotnet-132521-frbouche)
- [MSDeploy VS. ZipDeploy](https://learn.microsoft.com/en-us/azure/azure-functions/deployment-zip-push?WT.mc_id=dotnet-132521-frbouche)
- [Use a deployment button to deploy remote templates](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/deploy-to-azure-button?WT.mc_id=dotnet-132521-frbouche)