Series
Application Hosting on Azure: App Service, Containers and AKS
Azure will happily sell you four different ways to host the same web application, and the documentation for each one is written as though the other three don't exist. This series fixes that. It starts where the real decision starts — how much of the platform you want to own — and works outward from there: the control-versus-abstraction trade-off that separates App Service from Container Apps from AKS, the networking choices you cannot cheaply reverse once made, and the cost shapes that make one option quietly expensive at the scale you're actually operating at.
From there it goes deep on running each option well. On the App Service side: what each pricing tier genuinely buys, how deployment slots turn releases into routing changes, the difference between autoscale rules and automatic scaling and why every scale-out rule needs a partner, how to lock an app down at the network edge and authenticate users without writing auth code, custom domains and managed TLS, and what App Service backups do and don't capture. On the container side: where Container Instances earns its place and where its limits bite, how container groups and the sidecar pattern fit together, what a container registry costs and controls, and how the AKS control plane divides responsibility between Microsoft and you — plus the add-ons, from KEDA to Dapr to Istio, that make a cluster worth its operational weight.
Written for engineers and architects who need to make the call and then live with it. Every claim is checked against current Microsoft documentation rather than course material — which matters more than it sounds, because several things the training circuit still teaches have quietly changed underneath it: image signing via Docker Content Trust can no longer be switched on, App Service backups are losing linked-database support, and the compute metric everyone quotes for sizing was retired years ago. Where the source material was wrong, each post says so and shows the correction.
12 parts
- 1 Azure Hosting: App Service vs Container Apps vs AKS How to choose between App Service, Container Instances, Container Apps, and AKS: the control-versus-abstraction trade-off, scale-to-zero and cost shape, portability, and why the networking model is the part of the decision you can't cheaply reverse.
- 2 Azure App Service Plans: Pricing Tiers Compared How App Service plans allocate compute across the shared, dedicated, and isolated tiers. The feature cliffs between Basic, Standard, and Premium, what zone redundancy requires, and which limits are worth designing around before you pick a tier.
- 3🔒 Azure App Service: Web Apps, API Apps, and WebJobs The four workload styles App Service supports: web apps, API apps, WebJobs, and mobile backends — and what separates them. Plus the create-time choices: runtime and OS constraints, code versus container publishing, and the settings that only appear after creation.
- 4🔒 Azure App Service Deployment Slots and Swaps How deployment slots enable zero-downtime releases on App Service: what a swap actually does, which settings travel with the swap and which stay pinned to the slot, auto swap and its Linux limitation, and traffic percentage routing for canary releases.
- 5🔒 Azure App Service Autoscale Rules and Automatic Scaling How App Service scales: vertical versus horizontal, manual versus automatic, metric- and schedule-based autoscale rules and their OR semantics, the newer HTTP-driven automatic scaling option, and why every scale-out rule needs a matching scale-in rule.
- 6🔒 Secure Azure App Service: Access Restrictions and Easy Auth Controlling traffic into and out of an App Service app: access restrictions and IP-based ACLs for inbound, virtual network integration for outbound routing and NSG rules, and how App Service's built-in authentication module runs beside your code without an SDK.
- 7🔒 Azure App Service Custom Domains and TLS Certificates Binding a custom domain to an App Service app: why root domains need an A record rather than a CNAME, how TXT records prove ownership, SNI bindings, App Service managed certificates, and the certificate format that actually works.
- 8🔒 Azure App Service Backups: Automatic vs Custom The two backup types App Service offers and how they differ in size, retention, and configuration: what each one captures, the restore semantics that can delete files, the storage account requirements, and the linked-database deprecation that changes the picture.
- 9 Azure Container Instances and Container Groups What Azure Container Instances is genuinely good at and where its limits bite, how container groups colocate containers around the sidecar pattern, and how Container Apps fills the gap between a bare container and a Kubernetes cluster.
- 10🔒 Azure Container Registry: Tiers and Image Publishing How Azure Container Registry stores and serves container images: what each service tier includes and which features are Premium-only, the pull-tag-push workflow, registry access control, and why Docker Content Trust has been replaced by the Notary Project.
- 11🔒 AKS Architecture: Control Plane and Node Components How AKS splits responsibility between a Microsoft-managed control plane and customer-managed nodes: what each control plane and node component does, why a single-node cluster gives you nothing, and how Container Apps compares for teams without Kubernetes expertise.
- 12🔒 Scaling and Extending AKS: HPA, KEDA, Dapr, and Istio The add-ons that make AKS do more than run pods: horizontal pod autoscaling and KEDA's event-driven scale-to-zero, Dapr's state and pub/sub building blocks, Istio's traffic splitting for canary releases, and ingress controllers for exposing services.