azure-compute

Files (1)

• SKILL.md

SKILL.md (first lines)

# Azure Compute

Choose the compute option with the lowest operational burden that meets your workload's functional and non-functional requirements.
Managed services first; IaaS only when control is mandatory.

## Use This Skill When

- The user asks which Azure compute service to use (Functions vs. App Service vs. AKS)
- A workload must move from on-premises or another cloud to Azure
- The user needs trade-off analysis: cost, scaling, latency, compliance
- The user needs operational readiness assessment

## Context: Compute Maturity Spectrum

```
Serverless (Least ops):
  Azure Functions
  └─ Pro: Zero infrastructure, auto-scale, pay-per-exec
  └─ Con: Cold starts, max 10-min timeout, limited languages

PaaS (Low ops):
  App Service
  └─ Pro: Built-in scaling, diagnostics, deployment slots
  └─ Con: Single-region, limited customization
  
  Container Apps
  └─ Pro: Container-native, auto-scaling, event-driven
  └─ Con: Smaller ecosystem, newer service

Containers + Orchestration:
  Azure Kubernetes Service (AKS)
  └─ Pro: Full Kubernetes control, multi-region, custom scaling
  └─ Con: Requires Kubernetes expertise, higher operational burden

IaaS (Most control, Most ops):
  Virtual Machines / VMSS
  └─ Pro: OS-level control, custom binaries, legacy support
  └─ Con: Requires manual patching, scaling, monitoring
```

## Required Inputs

- **Workload type**: Web API, background job, ML training, legacy app, real-time analytics
- **Traffic pattern**: Constant, bursty, seasonal, event-driven
- **Latency requirement**: Sub-100ms, <500ms, or flexible
- **Availability**: 99%, 99.9%, 99.95%?
- **Scaling needs**: Min/max instances, target response time
- **Compliance**: On-premises only, specific regions, data residency
- **Team skills**: DevOps, Kubernetes expertise, vendor lock-in tolerance
- **Budget**: TCO vs. OpEx preference

## Decision Tree

```
Is this a background job triggered by an event (file upload, message queue, timer)?
├─ Yes → Azure Functions (lowest cost, auto-scale, easy)
│         But if: Job runs >10 min → Container Apps or App Service
└─ No → Continue

Is this a stateless HTTP API or web app?
├─ Yes → App Service (built-in scaling, diagnostics)
│         Or: Container Apps (if containerized, multi-region)
├─ Needs Kubernetes → AKS
└─ No → Continue

Does this need OS-level control (custom packages, specific kernel version)?
├─ Yes → Virtual Machines or VMSS
└─ No → One of above managed options

Is latency critical (< 100ms p99)?
├─ Yes → Consider colocating compute with data store (same region/AZ)
│         Evaluate: App Service Plan, VMSS, or Container Apps with CPU optimization
└─ No → Standard deployment acceptable

Do you need to orchestrate multiple microservices?
├─ Yes → AKS (service mesh, traffic mgmt, multi-region)
│         Or: App Service + API Management (simpler, less overhead)
└─ No → Single-service option (Functions, App Service)
```

## Workflow

### Phase 1: Characterize Workload

1. **Inventory current state**:
   - Runtime: Node.js, Python, .NET, Java, Go, etc.
   - Concurrency: Single-threaded, multi-threaded, async?
   - State: Stateless, session affinity, distributed cache?
   - Dependencies: Database, message queue, cache, external APIs?
   - Constraints: Max execution time, memory, disk I/O?

2. **Predict load profile**:
   - Baseline (off-peak): 10 req/sec
   - Average (peak): 100 req/sec
   - Spike (flash sale, viral event): 500 req/sec
   - Duration of spikes: Seconds or hours?

3. **Define SLA**:
   - Availability: 99% (5.2 hours downtime/month) vs. 99.95% (21 minutes/month)
   - Response time p99: Must be <500ms? <100ms?
   - Cost sensitivity: $500/month budget or flexible?

### Phase 2: Evaluate Candidates

**Candidate 1: Azure Functions**
```
✓ Event-driven, API-triggered, timer-based workloads
✓ Zero infrastructure, auto-scale to thousands
✓ Pay only for execution time
✗ Cold starts (first invocation 1-5 sec)
✗ Max 10-minute execution timeout
✗ Limited to 1.5 GB memory per invocation
✗ Not suitable for stateful or long-running tasks

Cost estimate: 1M invocations/month × $0.20/1M = $0.20 + compute duration charges
```

**Candidate 2: App Service**
```

From manu14357/zskills, MIT.

More from manu14357/zskills