azure-deploy

// Validate azure.yaml using MCP tool
const validation = await azure-azd({
  command: "validate_azure_yaml",
  parameters: { path: "./azure.yaml" }
});

User wants to deploy → Run detection workflow below

// Validate azure.yaml using MCP tool before proceeding
const validation = await azure-azd({
  command: "validate_azure_yaml",
  parameters: { path: "./azure.yaml" }
});

if (validation.errors && validation.errors.length > 0) {
  // Fix validation errors before deployment
  console.error("azure.yaml validation failed:", validation.errors);
} else {
  // Proceed with azd up
}

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
│   └── **See [Static Web Apps Guide](./reference/static-web-apps.md)**
├── vite.config.* → Vite-based (React/Vue/Svelte) → Static Web Apps
│   └── **See [Static Web Apps Guide](./reference/static-web-apps.md)**
├── gatsby-config.js → Gatsby → Static Web Apps
│   └── **See [Static Web Apps Guide](./reference/static-web-apps.md)**
├── astro.config.mjs → Astro → Static Web Apps
│   └── **See [Static Web Apps Guide](./reference/static-web-apps.md)**
├── nest-cli.json → NestJS → App Service
├── Has express/fastify/koa/hapi dependency → App Service
└── No framework, just static build → Static Web Apps

requirements.txt or pyproject.toml exists →
├── function_app.py exists → Azure Functions (v2 programming model)
│   └── **See [Azure Functions Guide](./reference/functions.md)**
├── Has flask dependency → App Service
├── Has django dependency → App Service
├── Has fastapi dependency → App Service
└── Has azure-functions dependency → Azure Functions
    └── **See [Azure Functions Guide](./reference/functions.md)**

*.csproj or *.sln exists →
├── <AzureFunctionsVersion> in csproj → Azure Functions
│   └── **See [Azure Functions Guide](./reference/functions.md)**
├── Blazor WebAssembly project → Static Web Apps
├── ASP.NET Core web app → App Service
└── .NET API project → App Service

pom.xml or build.gradle exists →
├── Has azure-functions-* dependency → Azure Functions
│   └── **See [Azure Functions Guide](./reference/functions.md)**
├── Has spring-boot dependency → App Service
└── Standard web app → App Service

index.html exists + no package.json/requirements.txt →
└── Pure static site → Static Web Apps
    └── **See [Static Web Apps Guide](./reference/static-web-apps.md)**

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

# 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

# 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

# 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

# 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

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

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

# 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[@]}"
}

# macOS
brew install azure-cli

# Windows (PowerShell)
winget install Microsoft.AzureCLI

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

**If multi-service detected → Recommend azd + Infrastructure as Code**
See [Multi-Service Deployment Guide](./reference/multi-service.md)

### 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:**
1. "What type of application is this? (static website, API, full-stack, serverless functions, containerized app)"
2. "Is your application already containerized with Docker?"
3. "Does your app need server-side rendering or is it purely client-side?"
4. "Do you need scheduled tasks, cron jobs, or event-driven processing?"
5. "Will you need a database, caching, or other Azure services?"

---

## Specialized Deployment Skills

**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

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

# macOS
brew install azd

# Windows
winget install Microsoft.Azd

# Linux
curl -fsSL https://aka.ms/install-azd.sh | 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

# 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

# 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

my-static-site/
├── azure.yaml           # azd configuration
├── dist/                # Static content goes here (NOT in root)
│   └── index.html
└── infra/
    ├── main.bicep
    ├── main.parameters.json
    └── staticwebapp.bicep

name: my-static-site
services:
  web:
    project: .
    # IMPORTANT: dist must point to a folder containing ONLY static content
    # Do NOT set dist to "." as it will include azure.yaml, infra/, .azure/, etc.
    # which causes deployment issues (stuck in "Uploading" state)
    dist: dist
    host: staticwebapp
    # IMPORTANT: Do NOT specify "language" for plain HTML sites
    # Setting language (e.g., "html", "js") causes errors like:
    # "language 'html' is not supported by built-in framework services"

@description('Name of the Static Web App')
param name string

@description('Location for the Static Web App')
param location string

resource staticWebApp 'Microsoft.Web/staticSites@2022-09-01' = {
  name: name
  location: location
  // REQUIRED: This tag links the Bicep resource to the service in azure.yaml
  tags: {
    'azd-service-name': 'web'
  }
  sku: {
    name: 'Free'
    tier: 'Free'
  }
  properties: {}
}

output name string = staticWebApp.name
output uri string = 'https://${staticWebApp.properties.defaultHostname}'

azd up

# 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>

# 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

# Initialize from scratch
azd init

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

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

// Validate azure.yaml using MCP tool
const validation = await azure-azd({
  command: "validate_azure_yaml",
  parameters: { path: "./azure.yaml" }
});

// Check for validation errors
if (validation.errors && validation.errors.length > 0) {
  // Report errors to user and fix before proceeding
  console.error("azure.yaml validation failed:", validation.errors);
  return;
}

# Provision infrastructure + deploy code
azd up

# For automation/agent scenarios - use --no-prompt to avoid interactive prompts
azd up --no-prompt

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

# Preview changes before deployment
azd provision --preview

# Manage environments
azd env new staging
azd env select staging
azd up --no-prompt

// If azd commands fail, get troubleshooting guidance
const troubleshooting = await azure-azd({
  command: "error_troubleshooting"
});

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

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