Azure Functions Deployment Strategies

Deployment is the process of taking function code from the local machine and making it run in Azure. Several deployment methods are available, from simple drag-and-drop in VS Code to fully automated CI/CD pipelines. Choosing the right deployment strategy depends on the team size, release frequency, and quality requirements.

Deployment Options Overview

┌──────────────────────────────────────────────────────────────┐
│              DEPLOYMENT OPTIONS                              │
│                                                              │
│  1. VS Code Azure Extension    ← Best for beginners          │
│  2. Azure CLI                  ← Fast command-line deploy    │
│  3. Azure Functions Core Tools ← Local tooling deploy        │
│  4. GitHub Actions (CI/CD)     ← Automated team workflow     │
│  5. Azure DevOps Pipelines     ← Enterprise CI/CD            │
│  6. ZIP Deploy                 ← Manual or scripted          │
│  7. Docker Container Deploy    ← Custom runtime scenarios    │
└──────────────────────────────────────────────────────────────┘

Method 1 – Deploy from VS Code

The Azure Functions extension in VS Code provides a one-click deployment experience. This method is best during learning or for small projects.

Steps

1. Open the project folder in VS Code
2. Click the Azure icon in the left sidebar
3. Expand the subscription and find the Function App
4. Right-click the Function App → "Deploy to Function App"
5. Confirm the deployment when prompted

┌──────────────────────────────────────────────────────────────┐
│             VS CODE DEPLOY FLOW                              │
│                                                              │
│  Local Code  →  VS Code Extension  →  Azure Function App     │
│  (project/)     (one click)           (running in cloud)     │
└──────────────────────────────────────────────────────────────┘

Method 2 – Deploy Using Azure CLI

The Azure CLI deploys functions from the terminal. This method works on any operating system and is easy to include in scripts.

# Step 1: Login to Azure
az login

# Step 2: Create a resource group (skip if already created)
az group create --name MyResourceGroup --location "East US"

# Step 3: Create a storage account (required for function app)
az storage account create \
  --name mystorageaccount \
  --location "East US" \
  --resource-group MyResourceGroup \
  --sku Standard_LRS

# Step 4: Create the function app in Azure
az functionapp create \
  --resource-group MyResourceGroup \
  --consumption-plan-location "East US" \
  --runtime node \
  --runtime-version 18 \
  --functions-version 4 \
  --name MyFunctionApp \
  --storage-account mystorageaccount

# Step 5: Deploy the code
func azure functionapp publish MyFunctionApp

Method 3 – Deploy Using Core Tools

Azure Functions Core Tools has a built-in publish command. Run this from the project root folder:

func azure functionapp publish MyFunctionApp

This command zips the project, uploads it to Azure, and restarts the function app. The output shows the live URLs of all deployed functions.

Method 4 – GitHub Actions (Recommended for Teams)

GitHub Actions automates deployment every time code is pushed to a specific branch. This is the recommended approach for any team or production application.

┌──────────────────────────────────────────────────────────────┐
│              GITHUB ACTIONS CI/CD FLOW                       │
│                                                              │
│  Developer pushes code to "main" branch                      │
│       │                                                      │
│       ▼                                                      │
│  GitHub Actions workflow triggers                            │
│       │                                                      │
│       ├── Step 1: Install dependencies (npm install)         │
│       ├── Step 2: Run tests (npm test)                       │
│       ├── Step 3: Build (if TypeScript)                      │
│       └── Step 4: Deploy to Azure Function App               │
│                      │                                       │
│                      ▼                                       │
│           New version live in Azure ✓                        │
└──────────────────────────────────────────────────────────────┘

GitHub Actions Workflow File (.github/workflows/deploy.yml)

name: Deploy Azure Function

on:
  push:
    branches:
      - main

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
      # Step 1: Get the code from GitHub
      - name: Checkout code
        uses: actions/checkout@v3

      # Step 2: Set up Node.js
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      # Step 3: Install dependencies
      - name: Install dependencies
        run: npm install

      # Step 4: Run tests
      - name: Run tests
        run: npm test

      # Step 5: Deploy to Azure Functions
      - name: Deploy to Azure Functions
        uses: Azure/functions-action@v1
        with:
          app-name: MyFunctionApp
          publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }}

Getting the Publish Profile

1. Open Azure Portal → Function App → Overview
2. Click "Get publish profile" and download the file
3. Open GitHub repository → Settings → Secrets and Variables → Actions
4. Create new secret: Name = AZURE_FUNCTIONAPP_PUBLISH_PROFILE, Value = content of the downloaded file

Deployment Slots – Zero-Downtime Releases

Deployment slots allow testing a new version of the function in production infrastructure without affecting the live version. Once testing passes, a slot swap puts the new version live instantly.

┌──────────────────────────────────────────────────────────────┐
│              DEPLOYMENT SLOTS                                │
│                                                              │
│  Production Slot (live)          Staging Slot (testing)      │
│  myapp.azurewebsites.net         myapp-staging.azurewebsites │
│  Running v1.0                    Running v2.0 (new release)  │
│                                                              │
│  Step 1: Deploy v2.0 to staging slot                         │
│  Step 2: Test v2.0 at staging URL                            │
│  Step 3: Swap slots (instant!)                               │
│  Result: Production now runs v2.0, staging has old v1.0      │
│                                                              │
│  Rollback: Swap again to go back to v1.0 instantly           │
└──────────────────────────────────────────────────────────────┘

Slot Commands via Azure CLI

# Create a staging slot
az functionapp deployment slot create \
  --name MyFunctionApp \
  --resource-group MyResourceGroup \
  --slot staging

# Deploy to staging slot
func azure functionapp publish MyFunctionApp --slot staging

# Swap staging to production
az functionapp deployment slot swap \
  --name MyFunctionApp \
  --resource-group MyResourceGroup \
  --slot staging \
  --target-slot production

Environment Configuration per Deployment

Settings marked as Slot Settings in Azure Portal stay with the slot after a swap. This ensures the production slot always uses production settings even after a swap.

Choosing a Deployment Method

Post-Deployment Verification

After deployment, verify the function works correctly in Azure:

# Test the deployed function using curl
curl https://MyFunctionApp.azurewebsites.net/api/HelloWorld?name=Ravi

# Or use the test tab in Azure Portal
# Azure Portal → Function App → Function → Code + Test → Test/Run