Azure Deploy Skill

Deploy applications to Azure with intelligent service selection, local preview, and guided deployment workflows.

Quick Start Decision Tree

code

User wants to deploy → Run detection workflow below

Phase 1: Application Detection

ALWAYS start by scanning the user's project to detect the application type.

Step 1.1: Check for Existing Azure Configuration

Look for these files first (HIGH confidence signals):

File Found	Recommendation	Action
`azure.yaml`	Already configured for azd	Use `azd up` to deploy
`function.json` or `host.json`	Azure Functions project	Deploy as Functions
`staticwebapp.config.json`	Static Web Apps project	Deploy as SWA

If found, skip to the appropriate deployment section.

Step 1.2: Detect Application Framework

Scan for configuration files and dependencies:

Node.js / JavaScript / TypeScript:

code

package.json exists →
├── next.config.js/mjs/ts → Next.js
│   ├── Has `output: 'export'` → Static Web Apps (SSG)
│   └── Has API routes or no export config → App Service (SSR)
├── nuxt.config.ts/js → Nuxt
│   ├── Has `ssr: false` or `target: 'static'` → Static Web Apps
│   └── Otherwise → App Service (SSR)
├── angular.json → Angular → Static Web Apps
├── vite.config.* → Vite-based (React/Vue/Svelte) → Static Web Apps
├── gatsby-config.js → Gatsby → Static Web Apps
├── astro.config.mjs → Astro → Static Web Apps
├── nest-cli.json → NestJS → App Service
├── Has express/fastify/koa/hapi dependency → App Service
└── No framework, just static build → Static Web Apps

Python:

code

requirements.txt or pyproject.toml exists →
├── function_app.py exists → Azure Functions (v2 programming model)
├── Has flask dependency → App Service
├── Has django dependency → App Service
├── Has fastapi dependency → App Service
└── Has azure-functions dependency → Azure Functions

.NET:

code

*.csproj or *.sln exists →
├── <AzureFunctionsVersion> in csproj → Azure Functions
├── Blazor WebAssembly project → Static Web Apps
├── ASP.NET Core web app → App Service
└── .NET API project → App Service

Java:

code

pom.xml or build.gradle exists →
├── Has azure-functions-* dependency → Azure Functions
├── Has spring-boot dependency → App Service
└── Standard web app → App Service

Static Only:

code

index.html exists + no package.json/requirements.txt →
└── Pure static site → Static Web Apps

Step 1.3: Detect Multi-Service Architecture

Check for complexity indicators that suggest azd + IaC:

code

Multi-service triggers:
├── Monorepo structure (frontend/, backend/, api/, packages/, apps/)
├── docker-compose.yml with multiple services
├── Multiple package.json in different subdirectories
├── Database references in config (connection strings, .env files)
├── References to Redis, Service Bus, Event Hubs, Storage queues
├── User mentions "multiple environments", "staging", "production"
└── More than one deployable component detected

If multi-service detected → Recommend azd + Infrastructure as Code See Multi-Service Deployment Guide

Step 1.4: Confidence Assessment

After detection, assess confidence:

Confidence	Criteria	Action
HIGH	Azure config file found (azure.yaml, function.json, staticwebapp.config.json)	Proceed with detected service
MEDIUM	Framework detected from dependencies	Explain recommendation, ask for confirmation
LOW	Ambiguous or no clear signals	Ask clarifying questions

Clarifying questions for LOW confidence:

•"What type of application is this? (static website, API, full-stack, serverless functions)"
•"Does your app need server-side rendering or is it purely client-side?"
•"Will you need a database, caching, or other Azure services?"

Phase 2: Local Preview (No Azure Auth Required)

Before deploying, help users test locally.

Static Web Apps - Local Preview

bash

# Install SWA CLI (one-time)
npm install -g @azure/static-web-apps-cli

# Start local emulator
swa start

# Or with specific paths
swa start ./dist --api-location ./api

# With a dev server proxy
swa start http://localhost:3000 --api-location ./api

Azure Functions - Local Preview

bash

# Install Azure Functions Core Tools (one-time)
npm install -g azure-functions-core-tools@4

# Start local Functions runtime
func start

# With specific port
func start --port 7071

App Service Apps - Local Preview

Use the framework's built-in dev server:

bash

# Node.js
npm run dev
# or
npm start

# Python Flask
flask run

# Python FastAPI
uvicorn main:app --reload

# .NET
dotnet run

# Java Spring Boot
./mvnw spring-boot:run

See Local Preview Guide for detailed setup instructions.

Phase 3: Prerequisites & Dependency Management

ALWAYS check and install missing dependencies before proceeding.

3.1 Azure Authentication (Auto-Login)

Check login status and automatically login if needed:

bash

# Check if logged in, auto-login if not
if ! az account show &>/dev/null; then
    echo "Not logged in to Azure. Starting login..."
    az login
fi

# Verify and show current subscription
az account show --query "{name:name, id:id}" -o table

If the user has multiple subscriptions, help them select the correct one:

bash

# List all subscriptions
az account list --query "[].{Name:name, ID:id, Default:isDefault}" -o table

# Set subscription
az account set --subscription "<name-or-id>"

3.2 Dependency Detection & Auto-Install

Run this check first and install any missing tools:

bash

# Check all dependencies at once
check_deps() {
  local missing=()
  command -v az &>/dev/null || missing+=("azure-cli")
  command -v func &>/dev/null || missing+=("azure-functions-core-tools")
  command -v swa &>/dev/null || missing+=("@azure/static-web-apps-cli")
  command -v azd &>/dev/null || missing+=("azd")
  echo "${missing[@]}"
}

3.3 Install Missing Tools

Azure CLI (required for all deployments):

bash

# macOS
brew install azure-cli

# Windows (PowerShell)
winget install Microsoft.AzureCLI

# Linux (Ubuntu/Debian)
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

Azure Functions Core Tools (for Functions projects):

bash

# npm (all platforms)
npm install -g azure-functions-core-tools@4

# macOS
brew tap azure/functions && brew install azure-functions-core-tools@4

# Windows
winget install Microsoft.AzureFunctionsCoreTools

Static Web Apps CLI (for SWA projects):

bash

npm install -g @azure/static-web-apps-cli

Azure Developer CLI (for multi-service/IaC):

bash

# macOS
brew install azd

# Windows
winget install Microsoft.Azd

# Linux
curl -fsSL https://aka.ms/install-azd.sh | bash

3.4 Project Dependencies

Detect and install project-level dependencies:

bash

# Node.js - install if node_modules missing
[ -f "package.json" ] && [ ! -d "node_modules" ] && npm install

# Python - create venv and install if missing  
[ -f "requirements.txt" ] && [ ! -d ".venv" ] && python -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt

# .NET - restore packages
[ -f "*.csproj" ] && dotnet restore

# Java - install dependencies
[ -f "pom.xml" ] && mvn dependency:resolve

Phase 4: Single-Service Deployment (Azure CLI)

4.1 Static Web Apps Deployment

Create resource and deploy:

bash

# Create resource group (if needed)
az group create --name <resource-group> --location <location>

# Create Static Web App
az staticwebapp create \
  --name <app-name> \
  --resource-group <resource-group> \
  --location <location> \
  --sku Free

# Get deployment token
az staticwebapp secrets list \
  --name <app-name> \
  --resource-group <resource-group> \
  --query "properties.apiKey" -o tsv

# Deploy with SWA CLI
swa deploy ./dist \
  --deployment-token <token> \
  --env production

Plain HTML Site (Single File or No Build Step):

For plain HTML sites without a build process, SWA CLI requires content in a dedicated folder:

bash

# Create output directory and copy files
mkdir -p dist && cp -r *.html *.css *.js *.png *.jpg *.svg dist/ 2>/dev/null || true

# Get deployment token
TOKEN=$(az staticwebapp secrets list \
  --name <app-name> \
  --resource-group <resource-group> \
  --query "properties.apiKey" -o tsv)

# Deploy from dist folder
swa deploy ./dist --deployment-token "$TOKEN" --env production

# Clean up temp folder (optional)
rm -rf dist

Smart defaults:

•SKU: Free for dev/test, Standard for production
•Location: SWA has limited regions - use centralus, eastus2, westus2, westeurope, or eastasia

See Static Web Apps Guide for detailed configuration.

4.2 Azure Functions Deployment

Create and deploy:

bash

# Create resource group
az group create --name <resource-group> --location <location>

# Create storage account (required for Functions)
az storage account create \
  --name <storage-name> \
  --resource-group <resource-group> \
  --location <location> \
  --sku Standard_LRS

# Create Function App
az functionapp create \
  --name <app-name> \
  --resource-group <resource-group> \
  --storage-account <storage-name> \
  --consumption-plan-location <location> \
  --runtime <node|python|dotnet|java> \
  --runtime-version <version> \
  --functions-version 4

# Deploy with func CLI
func azure functionapp publish <app-name>

Smart defaults:

•Plan: Consumption (pay-per-execution) for most cases
•Runtime version: Latest LTS for the detected language

See Azure Functions Guide for advanced scenarios.

4.3 App Service Deployment

Create and deploy:

bash

# Create resource group
az group create --name <resource-group> --location <location>

# Create App Service plan
az appservice plan create \
  --name <plan-name> \
  --resource-group <resource-group> \
  --location <location> \
  --sku B1 \
  --is-linux

# Create Web App
az webapp create \
  --name <app-name> \
  --resource-group <resource-group> \
  --plan <plan-name> \
  --runtime "<runtime>"

# Deploy code (zip deploy)
az webapp deploy \
  --name <app-name> \
  --resource-group <resource-group> \
  --src-path <path-to-zip> \
  --type zip

Runtime values by language:

•Node.js: "NODE:18-lts", "NODE:20-lts"
•Python: "PYTHON:3.11", "PYTHON:3.12"
•.NET: "DOTNETCORE:8.0"
•Java: "JAVA:17-java17"

Smart defaults:

•Plan SKU: B1 for dev/test, P1v3 for production
•Always use Linux (--is-linux) unless .NET Framework required

See App Service Guide for configuration options.

Phase 5: Multi-Service Deployment (azd + IaC)

When multiple services or infrastructure dependencies are detected, recommend Azure Developer CLI with Infrastructure as Code.

When to Use azd

•Multiple deployable components (frontend + API + functions)
•Needs database, cache, storage, or messaging services
•Requires consistent environments (dev, staging, production)
•Team collaboration with reproducible infrastructure

Initialize azd Project

bash

# Initialize from scratch
azd init

# Or use a template
azd init --template <template-name>

Project Structure

code

project/
├── azure.yaml              # azd configuration
├── infra/
│   ├── main.bicep          # Main infrastructure
│   ├── main.parameters.json
│   └── modules/            # Reusable modules
├── src/
│   ├── web/                # Frontend
│   └── api/                # Backend

Deploy with azd

bash

# Provision infrastructure + deploy code
azd up

# Or separately:
azd provision  # Create infrastructure
azd deploy     # Deploy application code

# Manage environments
azd env new staging
azd env select staging
azd up

See Multi-Service Guide for azure.yaml configuration. See Azure Verified Modules for Bicep module reference.

Troubleshooting Quick Reference

Common Issues

"Not logged in" errors:

bash

az login
az account set --subscription "<name>"

"Resource group not found":

bash

az group create --name <name> --location <location>

SWA deployment fails:

•Check build output directory is correct
•Verify deployment token is valid
•Ensure staticwebapp.config.json is properly formatted

Functions deployment fails:

•Verify host.json exists
•Check runtime version matches function app configuration
•Ensure storage account is accessible

App Service deployment fails:

•Verify runtime matches application
•Check startup command if using custom entry point
•Review deployment logs: az webapp log tail --name <app> --resource-group <rg>

See Troubleshooting Guide for detailed solutions.

Reference Files

Load these guides as needed for detailed information:

•📦 App Service Guide - Full App Service deployment reference
•⚡ Azure Functions Guide - Functions deployment and configuration
•🌐 Static Web Apps Guide - SWA deployment and configuration
•🖥️ Local Preview Guide - Local development setup
•🏗️ Multi-Service Guide - azd and IaC patterns
•📚 Azure Verified Modules - Bicep module reference
•🔧 Troubleshooting Guide - Common issues and fixes
•📋 Common Patterns - Shared commands (DRY reference)