Group 2: Managed App Compute
Platform-managed application runtimes: App Service, App Service Environment, Container Apps, Azure Spring Apps, Service Fabric, OpenShift. Focus: reduce infra toil vs raw VM(s) while keeping flexible deployment models.
Services & Core Identity
App Service
Managed web/app runtime (Windows/Linux) for HTTP APIs & sites. Simplifies deployments (slots, scaling).
- Use when: .NET/Node/Python/Java web APIs quickly.
- Scaling: manual or autoscale rules.
- Supports deployment slots (blue/green).
App Service Env
Isolated & dedicated App Service in a VNet for compliance, larger scale, advanced networking.
- Use when: isolation + network inspection required.
- Higher cost baseline vs multi-tenant.
- Same dev model as App Service.
Container Apps
Microservice/event container platform (Dapr, revisions, scale to zero) without full cluster mgmt.
- Use when: microservices + scale-to-zero + simple envoy ingress.
- Good for background jobs, HTTP APIs, events.
- Dapr bindings/service invocation optional.
Azure Spring Apps
Managed Spring Boot apps: built-in config server, service registry, diagnostics, autoscale.
- Use when: Spring microservices on JVM with minimal ops.
- Deep Spring integrations & monitoring.
- Commercial tier adds more enterprise features.
Service Fabric
Distributed systems platform for stateful + stateless services, actors model, rolling upgrades.
- Use when: need stateful microservices with low latency.
- Higher ops complexity than Container Apps.
- Supports containers + guest executables.
OpenShift
Red Hat managed Kubernetes + developer tooling (operators, source-to-image) with enterprise policies.
- Use when: enterprise OpenShift standardization.
- A layered opinionated K8s distribution.
- Higher baseline cost vs simpler PaaS.
Key Differences
| Dimension | App Service | App Service Env | Container Apps | Spring Apps | Service Fabric | OpenShift |
|---|---|---|---|---|---|---|
| Primary Focus | Web/API PaaS | Isolated Web/API | Microservices/event | Spring microservices | Stateful services | Enterprise K8s distro |
| Scale to Zero | No | No | Yes (per revision) | No | No | No |
| Stateful Support | External only | External only | External (Dapr state) | External only | Built-in stateful | Via K8s patterns |
| Dapr Integration | No | No | Native | No | No | Manual add |
| Ops Complexity | Low | Low/Medium | Medium | Medium | High | High |
| Traffic Strategy | Slots | Slots | Revisions % split | Instance routing | Rolling upgrades | Routes / Operators |
| Vendor Lock | Moderate | Moderate | Low (OCI images) | High (Spring focus) | High (platform APIs) | Medium |
| Latency Overhead | Low | Low | Low/Med (envoy) | Low | Low | Medium |
| Ideal Team Skill | App dev | App dev + net | Dev + microservice | Spring dev | Distributed systems | K8s + ops |
| Enterprise Network | Limited | Full (VNet) | VNet integ | VNet integ | Full control | Full control |
Mathematical Selection Model
Adjust criteria [0..10]. Weighted scores approximate suitability. High = better fit.
Score_AppSvc = 0.30*C_web + 0.20*C_lowops + 0.15*C_speed + 0.10*(10 - C_stateful) + 0.15*(10 - C_k8s) + 0.10*C_cost
Score_AppSvcEnv = 0.25*C_web + 0.20*C_isolation + 0.15*C_network + 0.15*C_lowops + 0.10*C_speed + 0.15*(10 - C_stateful)
Score_ContainerApps = 0.30*C_micro + 0.20*C_event + 0.15*C_scalezero + 0.10*C_lowops + 0.15*C_polyglot + 0.10*(10 - C_stateful)
Score_Spring = 0.35*C_spring + 0.20*C_lowops + 0.15*C_observ + 0.10*C_speed + 0.10*(10 - C_stateful) + 0.10*C_integration
Score_SvcFabric = 0.30*C_stateful + 0.20*C_actor + 0.15*C_lowlat + 0.15*C_upgrades + 0.10*C_density + 0.10*C_control
Score_OpenShift = 0.30*C_enterprise + 0.20*C_k8s + 0.15*C_policy + 0.15*C_operator + 0.10*C_multi + 0.10*C_security
App Service {{vm.scores.appsvc | number:2}}
ASE {{vm.scores.ase | number:2}}
Container Apps {{vm.scores.ca | number:2}}
Spring Apps {{vm.scores.spring | number:2}}
Service Fabric {{vm.scores.sf | number:2}}
OpenShift {{vm.scores.ocp | number:2}}
Recommended: {{vm.recommended.name}} ({{vm.recommended.score | number:2}})
Interpretation Rules
- If C_spring ≥ 7 → Spring Apps unless cost constraints extreme.
- If C_stateful ≥ 7 AND low-latency actors → Service Fabric.
- If C_scalezero ≥ 6 AND C_event ≥ 6 → Container Apps.
- If C_isolation ≥ 7 OR C_network ≥ 7 → App Service Environment.
- If team lacks K8s skill and C_web high → App Service.
- If enterprise standardization + operators/policy ⇒ OpenShift.
When NOT to Use Managed App Compute
- Ultra low-level OS/driver control → Core Compute (VM/VMSS).
- Simple event functions or connectors → Serverless group (index333).
- Stateful DB tier → Use PaaS DB or Data group.
Summary
App Service for rapid web APIs. ASE for isolation/VNet control. Container Apps for microservices + scale-to-zero + Dapr. Spring Apps for Spring Boot fleets. Service Fabric for stateful, actor-based or high-control microservices. OpenShift for enterprise K8s with policy/operator model. Start from runtime style (web/micro/event/stateful) then refine via isolation and operational skill factors.