AZ-104 Compute
Deploy & manage Azure compute resources
Deploy & Manage Compute — MOC
MS Learn path: Deploy and manage Azure compute resources · From traditional VMs to serverless — the full compute spectrum.
Map / Canvas
The core idea
Compute is where workloads run. The current AZ-104 blueprint concentrates on VMs, App Service, Container Instances, Container Apps, Container Registry, and ARM/Bicep deployments. AKS and Functions remain useful context, but they are not a substitute for those assessed administration skills.
Concepts (linked from here)
Virtual machines
- Azure Virtual Machines
- VM sizes & families
- Managed disks, ephemeral OS disk
- Snapshots & images
- Availability set
- Availability zones / VMSS
- Virtual Machine Scale Sets (VMSS)
- VM extensions & custom script
- Moving / resizing VMs
- VM encryption at host
Infrastructure as Code
- Bicep
- ARM templates
- Azure CLI & PowerShell (compute ops)
Platform as a Service
- Azure App Service
- App Service plans
- Deployment slots
- Azure Container Apps
- App Service TLS, custom domains & certs
- App Service backup
- App Service networking
Containers
Context only (not a current AZ-104 objective)
Modules in this path
Grounded in MS Learn: Deploy and manage Azure compute resources (
az-104-manage-compute-resources) — 5 modules.
- Introduction to Azure virtual machines
- Configure virtual machine availability
- Configure Azure App Service plans
- Configure Azure App Service
- Configure Azure Container Instances
Skills measured
- Create & configure virtual machines
- Manage VM disks, availability & scaling
- Deploy & manage App Service
- Provision and manage containers (ACR, ACI, Container Apps, sizing and scaling)
- Automate deployments with ARM templates or Bicep
Practice questions
- Q: VM availability options
- Q: App Service plan scale
- Q: VMSS autoscale
- Q: single container with ACI
- Q: deployment slots
- Q: Container Apps scaling
- Q: portal deployment to Bicep
- Q: App Service custom domain and TLS
Ordered practice route
- Complete the VM introduction and availability modules, then az104-vm-lifecycle-disk-move-lab. You should now be able to trace a VM’s compute, disk, move, and encryption boundaries.
- Complete configure-azure-container-instances, then az104-acr-container-app-revisions-lab. You should now be able to grant image pull access and roll a revision back without confusing rollout with scaling.
- Complete az104-bicep-deploy-rollback-lab. You should now be able to preview, deploy, diagnose, and restore a small desired-state change.
- Complete configure-app-service-plans and configure-azure-app-services, then az104-app-service-ingress-lab. You should now be able to choose app-plan boundaries and trace inbound TLS/private access separately from outbound VNet integration.
Conceptual checkpoint
Explain the sequence in this path using one workload scenario: identify the boundary being changed, the identity or tool acting on it, the expected evidence, and the failure that would change your decision.
Sources and re-audit
- AZ-104 course overview, checked 2026-08-31.
- AZ-104 study guide, checked 2026-08-31.
Re-audit when the AZ-104 course path, study-guide effective date, or the services and permissions taught here change.
Module 1 — Introduction to Azure virtual machines
Grounded in MS Learn: az-104-manage-compute-resources → Introduction to Azure virtual machines (
learn.introduction-to-azure-virtual-machines)
Overview
First module of the AZ-104 compute path. Learn the decisions you make before creating a virtual machine: what to plan for, the compute/size choice, storage/count of disks, and the tooling used to create and operate the VM.
Units (from learning objectives)
- Compile a checklist for creating a virtual machine
- Options to create and manage virtual machines
- Additional services used to administer VMs (extensions, monitoring, backup)
Learning objectives (authoritative)
- Compile a checklist for creating a virtual machine.
- Describe the options to create and manage virtual machines.
- Describe the additional services available to administer virtual machines.
Concepts introduced
- Azure Virtual Machine — IaaS computing with full guest-OS control.
- VM sizes & families — vCPU/memory profile selection.
- Managed disks — OS + data disk types, ephemeral OS disk.
- VM extensions — post-deploy guest automation (e.g. Custom Script Extension).
- Logistics: resource group, region, networking (VNet/subnet), authentication, and availability options ([[]] availability-set / availability-zones planned later).
Key terms & commands
- Provision:
az vm create --resource-group <rg> --name <vm> --image UbuntuLTS --size Standard_D2s_v3 --generate-ssh-keys - Manage:
az vm start / stop / deallocate / restart / redeploy,az vm list,az vm show - Sizes:
az vm list-sizes --location <region> - Create checklist: resource group → size (right-size vCPU/RAM) → OS + image → disks (type/tier, ephemeral vs persistent) → networking & public IP → auth (SSH keys / password / Entra) → availability (set vs zones vs none) → extensions & monitoring.
Hands-on
- Create a Linux VM via CLI, connect with SSH, install software via Custom Script Extension rather than manual login.
- Compare ephemeral vs persistent OS disk behavior (deallocate → restart → data loss on ephemeral).
Exam focus
- The pre-creation checklist and choosing an appropriate size/family for the workload.
- Deallocate vs delete: deallocated VM still bills for disks but not CPU; delete removes resources.
- Recognize VM administration services: extensions, Azure Monitor, backup, Virtual Machine Scale Sets.
Related
Path MOC · azure-vm · vm-sizes · managed-disks · vm-snapshot · azure-vm-extension · Next: VM availability
Module 2 — Configure virtual machine availability
Grounded in MS Learn: az-104-manage-compute-resources → Configure virtual machine availability (
learn.wwl.configure-virtual-machine-availability)
Overview
Second module of the AZ-104 compute path. Configure high availability and scaling for VMs: availability sets, availability zones, fault/update domains, Virtual Machine Scale Sets, and autoscaling.
Learning objectives (authoritative)
- Implement availability sets and availability zones.
- Implement update and fault domains.
- Implement Azure Virtual Machine Scale Sets.
- Autoscale virtual machines.
Concepts introduced
- Availability set — fault domains (FDs) + update domains (UDs) within a region; ≥2 VMs for SLA.
- Availability zones — physically isolated datacenters in a region for zone-level failure tolerance.
- Fault domain vs update domain semantics (rack/power isolation vs sequential maintenance reboots).
- Virtual Machine Scale Sets (VMSS) — identical VM fleets with horizontal scale + automatic FD/zone spreading.
- Autoscaling — vertical (size) vs horizontal (scale out/in) scaling rules on min/max instances.
Key terms & commands
- Availability:
az vm create --zone 1(zonal) vs availability-set viaaz vmss/az vm availability-set. - Scale sets:
az vmss create --instance-count 5 --autoscale-min 3 --autoscale-max 10 - Autoscale rules:
az monitor autoscale create --resource <vmss> --min 3 --max 10 --count 5(CPU% / metric / schedule based). - “Vertical” = resize VM size (deallocate →
az vm resize); “Horizontal” = add/remove instances in a scale set.
Hands-on
- Create a 2-VM availability set and confirm FD/UD assignment → shows rack-level protection.
- Build a VMSS with autoscale on CPU%, trigger load and watch instances scale out>in.
- Compare a zonal VM deployment (choose zone) with a regional one.
Exam focus
- Availability set vs availability zones — mutually exclusive for one VM/scale set; when each applies.
- Fault domain (hardware share) vs update domain (maintenance group) — classic questions.
- Horizontal scaling = scale sets; vertical scaling = resize a VM/instance.
- Autoscale requires setting min/max and a default count; rules can be metric- or schedule-based.
- 2+ VMs in a set → availability SLA; zones → higher/99.99% resilience where supported.
Related
Path MOC · availability-set · availability-zones · virtual-machine-scale-set · azure-vm · Prev: VMs
Module 3 — Configure Azure App Service plans
Grounded in MS Learn: az-104-manage-compute-resources → Configure Azure App Service plans (
learn.wwl.configure-app-service-plans)
Overview
Third module of the AZ-104 compute path. Decide which App Service plan pricing tier / SKU to use and how to scale the plan — the container and billing unit that hosts App Service web apps, APIs, and Functions apps.
Learning objectives (authoritative)
- Select an appropriate Azure App Service plan pricing tier.
- Scale an Azure App Service plan.
Concepts introduced
- App Service plans — the compute container + billing unit shared by apps on it.
- Pricing tiers: Free/Shared → Basic → Standard → Premium → Isolated; what features each tier unlocks (autoscale, staging slots, scale-out limits, VNet, zone redundancy, private endpoints).
- Scaling the plan: scale up (resize worker → more CPU/RAM per instance) and scale out (add instances; autoscale rules from Standard tier).
- How plan capacity, features, and instance counts affect every app in that plan.
Key terms & commands
- Create plan:
az appservice plan create --resource-group <rg> --name <plan> --sku S1 --is-linux - List SKUs:
az appservice list-locations/ cost-manager SKU grid; region SKU availability viaaz appservice plan+ Portal pricing page. - Scale up: change
--sku(e.g. S1→P1v3). Scale out: autoscale rules/min–max on the plan. - Tier → feature mapping is central: autoscale & staging slots need Standard+; Private Endpoint/VNet integration typically Premium; Isolated = App Service Environment.
Hands-on
- Provision an S1 plan, host two web apps, then scale out with an autoscale rule on CPU%.
- Compare a Basic (manual scale, ≤3 instances) vs Premium (autoscale, more instances) behavior.
Exam focus
- Which features require which tier (memorize the gates: autoscale/staging = Standard+; private endpoints/VNet = Premium; ASE/isolation = Isolated).
- Scale up vs scale out for App Service and that autoscale is the automated scale-out.
- Multiple apps on one plan share resources (cost-saving but contention) — isolating critical apps is a design choice.
- Bigger SKU is not always “better” — pick tier by required features + load.
Related
Path MOC · app-service-plan · app-service · deployment-slots · Next: App Service
Module 4 — Configure Azure App Service
Grounded in MS Learn: az-104-manage-compute-resources → Configure Azure App Service (
learn.wwl.configure-azure-app-services)
Overview
Fourth module of the AZ-104 compute path. Provision and operate Azure App Service web apps hosted on an App Service plan: create an app, use deployment slots for safe releases, secure the app, configure custom domains, back up/restore, and enable Application Insights monitoring.
Learning objectives (authoritative)
- Identify features and usage cases for Azure App Service.
- Create an app with Azure App Service.
- Configure deployment settings, specifically deployment slots.
- Secure your Azure App Service app.
- Configure custom domain names.
- Back up and restore your Azure App Service app.
- Configure Azure Application Insights.
Concepts introduced
- Azure App Service — PaaS web/API/mobile backend hosting.
- App Service plans — the plan/instance the app runs under.
- Deployment slots — warm staging environments + zero-downtime swap.
- App Service authentication (Entra/social), managed TLS/SSL, IP restrictions, managed identities.
- Custom domains + TLS/Binding; backup & restore; Azure Application Insights telemetry.
Key terms & commands
- Create app:
az webapp create --resource-group <rg> --plan <plan> --name <app> --runtime "NODE|18-lts" - Deploy:
az webapp deploy --src-path <zip> --type zip; slots:az webapp deployment slot create --slot staging,az webapp deployment slot swap --slot staging - Custom domain:
az webapp config hostname add --hostname app.example.com+ validate (CNAME/alias) + TLS bind cert. - Backup:
az webapp config backup create; Monitoring:az monitor app-insights component+ enable on app.
Hands-on
- Create an app, deploy via ZIP, open a staging slot, deploy there, swap to production (observe zero downtime), and swap back to roll back.
- Add a slot (sticky) app setting so a production key does not move to staging during swap.
- Attach a custom domain with a cert and enable Application Insights to see requests/errors.
Exam focus
- Deployment slots workflow (deploy → validate → swap → rollback) and the slot-settings vs app-settings difference (sticky settings stay with their slot).
- App Service authentication = built-in identities module; custom domains need validation + TLS binding.
- Autoscale/scale actually lives on the plan (see module 3), not the app.
- Backup/restore of the app content + settings; Application Insights for runtime telemetry (not just VM diagnostics).
Related
Path MOC · app-service · app-service-plan · deployment-slots · Prev: plans
Module 5 — Configure Azure Container Instances
Grounded in MS Learn: az-104-manage-compute-resources → Configure Azure Container Instances (
learn.wwl.configure-azure-container-instances)
Overview
Fifth module of the AZ-104 compute path. Understand when to use containers vs virtual machines, the features/use cases of Azure Container Instances (ACI) — serverless containers with no orchestrator to manage — and how to implement container groups.
Learning objectives (authoritative)
- Identify when to use containers versus VMs.
- Identify the features and usage cases of Azure Container Instances.
- Implement Azure container groups.
Concepts introduced
- Azure Container Instances (ACI) — run single containers directly, pay per second, no cluster management.
- Containers vs VMs decision: containers share the host OS (lighter, faster start, less isolation) vs VMs virtualize the OS (heavier, more isolation/control).
- Container groups — ACI scheduling unit: one or more containers sharing lifecycle, network, and storage on the same host.
- Images come from Azure Container Registry or public registries.
- Networking options: public IP + DNS, or on a Virtual Network (VNet injection).
Key terms & commands
- Create:
az container create --resource-group <rg> --name <aci> --image mcr.microsoft.com/azuredocs/aci-helloworld --cpu 1 --memory 1 --ports 80 - From ACR:
az container create --image <acr>.azurecr.io/app:v1(authenticated via ACR integration). - Container groups: deploy a
.yml(ACI group) with multiple containers sharing the group;az container show. - Networking:
--os-type linux --dns-name-labelfor public DNS; VNet via--vnet. - Start/stop/restart/logs:
az container logs,az container start, pairwise withaz container list.
Hands-on
- Run the ACI hello-world image and browse the public IP.
- Deploy a container group YAML with an app + sidecar sharing the network, and verify they can talk.
- Compare boot/teardown of an ACI vs an equivalent VM to internalize the containers-vs-VMs tradeoff.
Exam focus
- Containers vs VMs deciding factor: shared-OS isolation vs full OS virtualization; containers for microservices/CI/batch.
- ACI = no orchestration: choose it for simple/short-lived/single or few containers; choose AKS for orchestrated fleets.
- Container groups = how ACI shares one host/network across multiple containers.
- Know
az containerverbs and that images commonly come from ACR. - ACI vs Functions: containers are stateful/persistent processes you control; Functions are event-driven serverless compute.
Related
VM
Azure Virtual Machine (VM)
What it is
An Azure virtual machine (VM) is a software-defined computer running on Azure infrastructure. It has an operating system, CPU and memory size, disks, and network interfaces. A VM is IaaS: Azure operates the physical hardware, but you operate the guest operating system and the software you install on it.
Why it exists
Some workloads need a real OS you can install anything on, tune, patch, and manage — existing on-premises apps, custom agents, licensed software. VMs give you that control without buying or racking hardware. You pay per second/hour for what you run.
Key ideas
- Choose a VM size for CPU, memory, disk, and network needs. A larger size costs more; a small size can become a bottleneck.
- A VM normally has an OS disk and can have data disks. Keep important application data off temporary local storage, which can be lost when the VM is deallocated or deleted.
- A virtual NIC connects the VM to a VNet subnet. A public IP, NSG, routes, and load-balancing design determine how traffic reaches it; a VM is not automatically public.
- You choose a secure administrator-access method and remain responsible for patching, configuration, applications, and data. Azure’s management of hardware does not patch the guest OS for you.
- One VM is a single compute instance. Use availability-zones, availability sets, or a scale set when the workload needs replicas or a larger availability design.
Northwind example
Northwind initially runs a legacy warehouse connector on one Linux VM because the software requires OS-level configuration. Luis selects a size, managed data disk, private subnet, and SSH key authentication. The VM can connect to the ordering application, but it is not a resilient design by itself: a VM or its zone can fail. Northwind later runs two connector instances behind a health-aware traffic path if continuity is required.
Common confusion
- Stopped and deallocated are different billing and capacity states. Check the current billing state before assuming compute charges have stopped; disks and other retained resources can still cost money.
- A VM image is the starting software template. A snapshot is a point-in-time copy. Neither alone is a tested application recovery plan.
- A VM is a compute resource, not a private network, firewall, backup, or load balancer.
How it fits (diagram)
Before creating one
Decide the resource group, region, size, operating-system image, disk type, network design, access method, monitoring, backup, and availability requirement. Use Bicep or ARM templates when a consistent, repeatable configuration is needed.
Related
vm-sizes · managed-disks · vm-snapshot · availability-set · availability-zones · virtual-machine-scale-set · azure-vm-extension · azure-cli · bicep · northwind-traders-case-study
📘 Source: Microsoft Learn — Virtual machines in Azure, checked 2026-09-16.
VM sizes and families
What it is
A VM size is a specific Azure VM configuration: a number of vCPUs, memory, storage-related capabilities, network capacity, and sometimes accelerators. Sizes are grouped into families designed for broad workload types, such as general-purpose, compute-optimized, memory-optimized, storage-optimized, GPU-accelerated, or high-performance compute.
Why it exists
Workloads need different balances of CPU, memory, storage throughput, network capacity, and accelerators. Choosing a size is a capacity and cost decision; it is not just a choice of CPU count.
Key ideas
- Naming is a clue, not a contract: a size name can indicate family, vCPU count, version, CPU vendor, storage support, accelerators, or other features. Consult the specific size specification before assuming what every letter means.
- Family choice: general-purpose sizes balance CPU and memory; compute-optimized favor CPU; memory-optimized favor RAM; storage-optimized favor disk throughput or IOPS; GPU and HPC families serve specialized workloads.
- Burstable sizes: B-family sizes suit workloads with low average CPU use that occasionally burst. They are not automatically appropriate for sustained production load.
- Regional availability and quota: a size may be unavailable in a region or limited by subscription quota. Check both before designing a fleet.
- Storage is separate: the OS/data disk choice and local temporary storage behavior are separate from the VM size, though a size can constrain supported disk features and count.
Northwind example
Northwind begins its low-traffic internal reporting service with a general-purpose size after measuring CPU, memory, disk, and network needs. When month-end reports show memory pressure, the team evaluates a memory-optimized size rather than simply adding more CPU. For a stateless web tier, it considers scaling out with VM Scale Sets instead of repeatedly resizing one VM.
The three pieces (memorize!)
- vCPU count → compute capacity.
- Memory (GiB) → working data and concurrent workload capacity.
- Disk and network limits → possible storage and connection throughput.
How it fits (diagram)
Exam notes
- A resize can require the VM to be stopped/deallocated, causing downtime. Check the supported resize path for the source and target size.
- vCPU quotas are regional and can apply by VM family; capacity can also constrain deployment.
- Temporary storage is not persistent. Put business data on managed data disks or another persistent service.
- AZ-104 care about choosing an appropriate size and knowing family purpose, not memorizing every SKU.
Related
Path MOC · azure-vm · virtual-machine-scale-set · managed-disks
📘 Source: Microsoft Learn — Vm Sizes
Azure managed disks
What it is
A managed disk is a block-level storage volume Azure manages for an Azure VM. It is the cloud equivalent of a server’s virtual hard drive. You choose its type and size; Azure manages the underlying storage infrastructure.
Why it exists
VMs need persistent boot and application-data storage without requiring the team to operate storage accounts for each virtual hard disk. Managed disks separate the VM’s compute lifetime from its persistent disks and provide several performance and resilience options.
Key ideas
- Disk types: Ultra Disk, Premium SSD v2, Premium SSD, Standard SSD, and Standard HDD offer different performance and cost characteristics. Choose based on measured workload needs, not the disk label alone.
- OS disk: every VM has one boot disk. Keep the operating system there; put application data on separate data disks when that improves recovery, maintenance, or performance isolation.
- Data disks: persistent managed disks attached to a VM for applications and data. The VM size constrains how many can attach and which types it supports.
- Temporary disk: most VMs also have local temporary storage, which is not a managed disk. It can lose data during maintenance, redeployment, or a stop operation; use it only for disposable items such as page files, swap, or
tempdbwhere appropriate. - Ephemeral OS disk: stores the OS on local VM storage for supported designs. It is useful for disposable, stateless fleets, but not for a VM whose OS state must survive host events.
- Snapshots and images: snapshots copy a disk at a point in time; generalized images are blueprints for creating VMs. Neither automatically replaces a tested backup plan.
- Resilience: managed disks offer locally redundant and zone-redundant options where supported. Storage redundancy protects disk copies, while application availability still requires an appropriate compute and recovery design.
Northwind example
Northwind runs its ordering application on a VM with one OS disk and separate data disks for application files. It uses temporary storage only for disposable cache. When Luis needs to test a risky disk change, Maya creates a snapshot and plans how to create a replacement disk if needed. For routine recovery, the team uses Azure Backup and verifies restores; a single ad-hoc snapshot is not its disaster-recovery plan.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: virtual-machines/managed-disks-overview
Exam notes
- A snapshot copies one managed disk. It does not coordinate a multi-disk database or application by itself.
- Temporary and ephemeral storage are not a safe location for persistent business data.
- Managed-disk encryption options include server-side encryption, Azure Disk Encryption, and encryption at host; choose the control required by the design.
Related
Path MOC · azure-vm · vm-snapshot · availability-set · virtual-machine-scale-set
VM snapshots and images
What it is
- A snapshot is a read-only, full point-in-time copy of one managed disk. It exists independently of the source disk and can create a new managed disk.
- An image is a VM blueprint used to create repeatable VMs. Azure Compute Gallery adds image versioning and regional replication for supported image workflows.
Why it exists
Snapshots help investigate or recover a disk state; images help build repeatable VM fleets. They solve different problems and should not be confused with a complete application backup or disaster-recovery plan.
Key ideas
- Recovery path: snapshot → create a new disk → attach it as a data disk or use it to create a replacement VM, depending on the scenario.
- Consistency: a snapshot is crash-consistent. Cleanly shut down or quiesce an application before using a snapshot as a VM recovery source when application consistency matters.
- One disk at a time: snapshots do not coordinate multiple disks. A database spread across disks needs a coordinated backup approach.
- Cost: snapshots are billed separately from their source disk, based on used data size. Delete unneeded snapshots under a controlled retention process.
- Generalized image: removes machine-specific information before a single template is deployed to many new VMs. Use the documented preparation process for the operating system.
Northwind example
Before an operating-system experiment, Maya snapshots Northwind’s test VM OS disk. If the test fails, she creates a replacement disk from the snapshot. For the production ordering database, she does not rely on independent disk snapshots; the team uses an application-aware backup approach and verifies restore order. For a new fleet of identical web VMs, it uses a prepared image and infrastructure-as-code instead.
How it fits (diagram)
Exam notes
- Snapshot = one disk copy at a point in time; it does not turn a running application into a coordinated backup.
- Use a generalized image for a reusable fleet; use Azure Backup for scheduled recovery protection.
Related
Path MOC · managed-disks · azure-vm · virtual-machine-scale-set
📘 Source: Microsoft Learn — Create a snapshot of a virtual hard disk
Availability
Availability set
What it is
An availability set is a logical group for two or more VMs that reduces the chance that related VMs fail or restart together. Azure spreads the VMs across fault domains and update domains inside a region. It is especially useful in a region that does not support availability zones, but it has less isolation than zones.
Why it exists
A single VM sits on one physical host — any host/rack failure or Azure patch cycle could kill it. Availability sets arrange VMs across independent failure boundaries for 99.95% service-level availability, without needing multiple regions.
Key ideas
- A fault domain is a group of infrastructure that can share a power source and network switch. Spreading VMs reduces the risk of one physical issue taking every copy down.
- An update domain is a group that Azure can restart together during planned maintenance. Azure works through update domains rather than intentionally restarting all of them at once.
- Use at least two functioning application instances and a way to send clients to a healthy instance. The availability set supplies placement; it does not route traffic, replicate data, or fix application bugs.
- An availability set works within a region and can still be affected by a datacenter-level failure. Availability zones provide a stronger physical-fault boundary when supported.
Northwind example
In a region without availability zones, Northwind places two warehouse connector VMs in one availability set and uses a health-aware internal load-balancing design. During planned maintenance, one update domain can restart while the other connector remains available. If the connector database is a single point of failure, the availability set does not solve that separate problem.
Common confusion
- An availability set is not an auto-scaling group. It does not add VMs when demand rises.
- It is not a backup or disaster-recovery solution for a full regional outage.
- You cannot make one VM highly available merely by naming or attaching it to an availability set; the application needs multiple usable instances.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: virtual-machines/availability-set-overview
When to choose it
Choose an availability set for compatible VM workloads that need in-region fault and maintenance separation where zones are not the right or supported choice. For new high-availability VM workloads, evaluate a flexible scale set and availability zones as well. Confirm current SLA terms separately from the design pattern.
Related
azure-vm · availability-zones · virtual-machine-scale-set · load-balancer · northwind-traders-case-study
📘 Source: Microsoft Learn — Availability sets overview, checked 2026-09-16.
Availability zones
What it is
An availability zone is a physically separate group of one or more datacenters inside one Azure region. Zones have independent power, cooling, and networking. Think of a region as a city-sized service area and zones as separate, well-connected buildings in that area: a serious problem at one building need not stop the others.
Many, but not all, Azure regions have availability zones. A zone-enabled region commonly exposes logical labels such as 1, 2, and 3. Those labels are not a global street address: the same label can map to a different physical zone in another subscription.
Microsoft diagram: What are availability zones?
Why it exists
A single virtual machine or data copy can fail with the datacenter that hosts it. Spreading independently usable parts of a workload across two or more zones reduces that single-datacenter risk while keeping the workload in one region. It does not protect against a whole-region outage, a bad software release, deleted data, or an incorrectly configured identity.
How it works
Azure services support zones in one of three ways:
- A zonal resource goes into one zone you select. It is isolated from other zones but is not, by itself, resilient to its own zone failing.
- A zone-redundant resource is distributed or replicated across multiple zones by the Azure service. The service manages the cross-zone placement and failover.
- A regional (nonzonal) resource has no zone choice. Azure places it within the region; do not assume it survives a zone failure.
For zonal resources, the customer must build the pattern: multiple instances in different zones, a way to route traffic to a healthy instance, and a plan for state and data. The exact choices depend on the service and its available SKUs. Check the service reliability guide and region support before treating a design as zone-resilient.
Northwind example
Northwind runs two copies of its ordering application in one zone-enabled region: one VM in zone 1 and another in zone 2. A load balancer sends shoppers only to the healthy copy. Its order data uses zone-redundant storage. If zone 1 loses power, the zone-2 application and the replicated data can continue serving orders.
This is still a single-region design. If the whole region is unavailable, Northwind needs a separate multi-region recovery design, plus backups for accidental deletion or corruption.
Compare the close terms
| Term | Protects mainly against | What you must remember |
|---|---|---|
| Availability zone | A failure affecting one zone | It is a physical-fault boundary within a region. |
| zone-redundant | A single-zone failure | Azure spreads a supported service across zones. |
| availability-set | Some hardware and planned-maintenance failures within a datacenter | It is not a substitute for cross-zone placement. |
| Region pair or multi-region design | A regional outage | It requires a separate design and failover plan. |
| Backup | Deleted, corrupted, or historical data | Replication does not undo a bad write. |
Tradeoffs and failure modes
- Cross-zone traffic, supported SKUs, and replicated components can change cost or latency; test the actual workload.
- Putting every component in different zones can still fail if the database, DNS, credentials, or traffic-routing layer is a single point of failure.
- A one-zone VM is zonal, not highly available. A region that has zones does not make every deployed resource zone-resilient automatically.
- Zone numbers should not be compared across subscriptions without checking the subscription-specific mapping.
Where it appears in the route
Start with AZ-900 architecture. Then use AZ-104 compute to choose service-specific resiliency settings.
Sources and re-audit
- Microsoft Learn — What are availability zones?, checked 2026-09-16.
- Microsoft Learn — Azure reliability guides by service, checked 2026-09-16.
Related
zone-redundant · azure-region · availability-set · virtual-machine-scale-set · redundancy-lrs-zrs-grs · azure-backup
Virtual Machine Scale Sets (VMSS)
What it is
A Virtual Machine Scale Set (VMSS) manages a group of virtual-machine instances as one application fleet. It can create, configure, update, and automatically add or remove instances as demand changes. A scale set normally sits behind a traffic-distribution design such as Azure Load Balancer or Application Gateway.
Why it exists
Individually managing dozens of identical VMs is impossible to scale — patching, load distribution, and right-sizing would be manual. Scale sets give automatic scale-out/in (by metric/CPU/time), homogeneity, and fleet-level manageability.
Key ideas
- Scale out adds instances; scale in removes them. Scale up changes the size of an instance. Horizontal and vertical scaling solve different capacity problems.
- Autoscale can respond to a metric or schedule within a configured minimum and maximum. It is not magic forecasting: choose a relevant signal, leave time for new VMs to start, and test the rules.
- Scale sets support orchestration modes. The selected mode affects available features and cannot be changed after creation, so choose it deliberately.
- Multiple instances improve application resilience only when traffic reaches healthy instances and the application handles state correctly. A scale set can use fault domains or availability zones according to its configuration.
- Treat instances as replaceable. Keep durable state in an appropriate managed data service or disk design, not only on an instance’s temporary local storage.
Northwind example
Northwind’s public ordering front end becomes busy at lunchtime. A scale set starts with two healthy instances behind a load balancer, adds instances when tested demand metrics cross a threshold, and removes excess instances later. Each new instance comes from the same reviewed configuration and reads order data from shared storage. If Northwind stored the only copy of an order on one instance’s local disk, scale-in or a failure could lose it.
Common confusion
- A scale set is not a single VM with more CPU. It manages several instances.
- Autoscale does not protect a one-instance database or a dependency outside the scale set.
- A load balancer distributes traffic; it does not make unhealthy application code healthy. Health probes and application behavior matter.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: virtual-machine-scale-sets/overview
Safe rollout and tradeoffs
- A scale-out event can take time and can fail if the image, quota, capacity, or startup configuration is wrong.
- Updating the image or configuration needs a controlled rollout strategy so healthy instances remain available.
- More instances increase cost. Set reasonable minimums and maximums, alert on unexpected scaling, and review the metric that triggered it.
Related
azure-vm · vm-sizes · availability-set · availability-zones · managed-disks · azure-vm-extension · load-balancer · application-gateway · northwind-traders-case-study
📘 Source: Microsoft Learn — Virtual Machine Scale Sets overview, checked 2026-09-16.
Azure VM extensions
What it is
Azure VM extensions are small applications Azure installs into a VM’s guest operating system to perform post-deployment configuration or automation. Examples include running a script, installing a monitoring agent, configuring security tooling, or collecting diagnostics.
Why it exists
Instead of signing in to every VM to do the same setup, a team can declare an extension in the VM or scale set model and have Azure manage its installation. This makes a repeatable setup possible through the portal, CLI, or infrastructure-as-code template.
Key ideas
- Custom Script Extension runs a command or script in the guest OS. It is useful for a bounded setup task, such as installing the order-service package.
- The VM Guest Agent is the delivery path. Most extensions require an appropriate guest agent and extension-specific prerequisites such as a supported OS or access to a download endpoint.
- Extensions vary by purpose. Examples include Azure Monitor, VM access, antimalware, disk encryption, and diagnostics extensions. Check the individual extension’s support and behavior instead of assuming every extension works on every image.
- Treat scripts as production code. Store them in source control, make them safe to rerun where possible, log their results, and avoid embedding secrets. Use a managed identity and Key Vault when a workload must retrieve a secret.
- Extensions are not a universal configuration-management platform. Use them for well-defined guest tasks and choose a suitable desired-state or image/IaC strategy for ongoing configuration needs.
Northwind example
Northwind deploys a new set of web VMs from a known image. A Custom Script Extension installs the current web package and registers the service with the local OS. The script checks whether that version is already installed, so a redeployment does not break a healthy VM. It reads the required database endpoint from a non-secret configuration source and uses the VM’s managed identity to retrieve any necessary secret at runtime; it does not place credentials in the extension command.
How it fits (diagram)
Exam notes
- Custom Script Extension performs a declared guest-OS task after VM deployment; write the script to tolerate reruns.
- The guest agent and extension prerequisites must be healthy and reachable.
- Use extension output and VM health information to troubleshoot failure; do not assume an ARM deployment success means guest configuration succeeded.
Related
Path MOC · azure-vm · azure-cli · arm-template · virtual-machine-scale-set
📘 Source: Microsoft Learn — Azure VM extensions and features
IaC
Bicep
What it is
Bicep is a domain-specific language (DSL) that lets you define Azure infrastructure declaratively as code, with an easy-to-read, concise syntax. It transpiles to ARM template JSON before deployment, so it is a friendlier authoring layer over the same Azure Resource Manager deployment engine.
Why it exists
ARM templates (JSON) are verbose, hard to read, and error-prone. Bicep gives you the same declarative infrastructure-as-code power — variables, parameters, modules, loops, conditions, dependencies — with syntax like a modern language, plus native tooling (formatter, linter, VS Code extension, preview of changes).
Key ideas
- Bicep files use the
.bicepextension and compile to ARM-template JSON. Azure tools can deploy Bicep directly, but Azure Resource Manager performs the deployment. - Declarative means the file states the desired resources and properties. It does not mean every unspecified resource will be removed: deployment scope and mode determine how Azure handles existing resources.
- Parameters make the same definition usable for dev, test, and production. Modules package reusable pieces, such as a standard network or storage account.
- Bicep can infer many dependencies from resource references, so it can order the deployment. Make any non-obvious dependency explicit and review the planned change.
Northwind example
Northwind keeps a Bicep definition for the ordering app’s resource group, App Service plan, web app, storage account, and monitoring. It passes different parameter values for test and production, reviews the change in version control, then deploys through Azure Resource Manager. A manual portal change can still create drift, so Northwind compares the live environment with its reviewed definition.
Common confusion
- Bicep is an authoring language; ARM is the Azure deployment and management service.
- Bicep is not an application-programming language and does not run Northwind’s ordering code.
- Re-running a deployment is not a substitute for understanding destructive changes, deployment mode, or a resource’s update behavior.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: azure-resource-manager/bicep/overview
Exam notes
- Bicep compiles to (maps 1:1 to) an ARM template — they are two views of the same deployment.
- Files end in
.bicep;az deploymenttargets resource-group or subscription scope. - In AZ-104 pop quiz: “declarative, readable language for Azure IaC” → Bicep (vs imperative CLI/portal); preferred over hand-writing JSON.
- Same deployment engine as ARM templates → idempotent diff-based apply.
Related
arm-template · infrastructure-as-code · azure-cli · azure-vm · northwind-traders-case-study
📘 Source: Microsoft Learn — Bicep overview, checked 2026-09-16.
ARM templates
What it is
An ARM template is a JSON file that declaratively describes Azure resources, their properties, and their relationships. Azure Resource Manager reads it and performs a deployment at the selected scope. It gives a team a repeatable record of intended infrastructure, but the exact update and deletion behavior depends on the resource types and deployment mode.
Why it exists
Clicking through the Portal or imperative CLI is fine for one resource but not reproducible or auditable for a fleet. Templates make infrastructure code: versioned in git, reviewed, reused with parameters, and safely re-run (no surprise re-provisions).
Key ideas
- The
resourcessection describes the Azure resources to deploy. Parameters and outputs let one template be reused and connected to other deployment steps. - Templates can deploy at resource-group, subscription, management-group, or tenant scope. Scope determines which resource types and governance settings can be targeted.
- Incremental deployment updates or adds declared resources but does not automatically delete every resource omitted from the template. Complete-mode behavior can remove undeclared resources at the deployment scope and must be treated as potentially destructive.
- Bicep is the modern Azure-native authoring language that compiles to ARM JSON. Use either deliberately; do not assume exported portal JSON is a production-ready design.
Northwind example
Northwind deploys an ARM template at the orders-production resource-group scope. The template declares the ordering app and storage settings, while parameters provide the production name and region. Before changing a resource, the team reviews the template change and deployment impact. It does not use complete mode casually, because an omitted resource at that scope could be deleted.
Common confusion
- ARM template is the JSON definition; Azure Resource Manager is the service that executes it.
- A template is not a backup. It can recreate infrastructure configuration, but data recovery needs an appropriate backup and restore plan.
- Declarative does not eliminate the need for permission, Policy compliance, quotas, capacity, or review of destructive changes.
How it fits (diagram)
Exam notes
- ARM template vs MPI (managed identity): not related — templates are IaC.
- Incremental vs complete deployment modes: incremental only adds/changes listed resources; complete deletes resources in the RG not in the template (dangerous — default is incremental).
- Linked/nested templates with
deploymentsresource for modularity. - Exam: recognize template JSON anatomy and that it’s declarative + idempotent.
Related
bicep · infrastructure-as-code · azure-cli · azure-vm · arm · northwind-traders-case-study
📘 Source: Microsoft Learn — What are ARM templates?, checked 2026-09-16.
Azure CLI
What it is
Azure CLI is Microsoft’s cross-platform command-line tool for working with Azure. Its commands start with az. You can run them interactively in a terminal or place them in scripts for repeatable administration and deployment tasks.
Why it exists
Clicking through a portal is useful for learning and investigation, but repeated work needs a recordable process. The CLI lets Northwind express a task as commands that can be reviewed, tested, versioned, and rerun with appropriate safeguards.
Key ideas
- Command groups reflect Azure tasks, such as
az group,az vm,az storage, andaz deployment. Useaz helpand current reference documentation rather than memorizing a long command list. - The CLI can run locally on Windows, macOS, and Linux, in a container, or in Cloud Shell. It is the tool, not the terminal program that hosts it.
- Authenticate with an appropriate method for the situation. An interactive human sign-in differs from a workload identity or service principal used by automation.
- The active subscription is part of command context. Set or verify it before any command that can change resources; a valid login can still point at the wrong subscription.
- JSON is the default output format. Other formats, such as a table for human reading, are available. Prefer machine-readable output for scripts and treat it as an interface that needs careful parsing.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: azure/cli/
Northwind example
Maya uses az to list the subscriptions she can access, deliberately selects Northwind production, and queries the resource group before a deployment. A pipeline uses a separate, least-privileged workload identity to deploy reviewed Bicep infrastructure. The team does not copy Maya’s interactive credentials into the pipeline or rely on a default subscription that might change between machines.
CLI versus portal and Cloud Shell
| Tool | Best starting use |
|---|---|
| Azure CLI | Scriptable, command-driven Azure work. |
| [[azure-portal | Azure portal]] |
| [[cloud-shell | Cloud Shell]] |
They use the same Azure authorization model. The chosen interface does not change what a user or workload is allowed to do.
Common confusion
- A command that succeeds has performed an Azure action; it is not merely a local preview unless its documentation says it is.
- CLI commands manage both control-plane resources and, in some cases, data-plane operations. Required permissions vary by command.
- A shell script is not automatically safe or idempotent. Handle existing resources, failures, retries, secrets, and the exact target scope deliberately.
Related
Path MOC · azure-vm · bicep · arm-template
Sources and re-audit
- Microsoft Learn — What is the Azure CLI?, checked 2026-09-16.
PaaS
Azure App Service
What it is
Azure App Service is Azure’s managed web-hosting platform for web apps, APIs, and supported web workloads. You deploy application code or a supported container; Azure operates the underlying web platform and operating system. Your team still owns the application’s code, identity, configuration, data, monitoring, and secure use of the platform.
Why it exists
Hosting a website by hand means provisioning VMs, installing a web server, patching the OS, and scaling manually. App Service abstracts all of that: deploy (via Git, ZIP, DevOps, or CI/CD) and the platform keeps it running and scales it on a plan.
Key ideas
- A web app is the application you deploy. An App Service plan supplies the compute capacity, pricing tier, scale settings, and supported features. They are separate resources.
- Scaling up changes the plan’s capacity; scaling out adds plan instances. Apps that share a plan share its compute resources and scaling effects.
- App Service supports web-platform capabilities such as custom domains, TLS, authentication integration, managed identities, access restrictions, VNet integration, and deployment slots, subject to the plan and configuration.
- App Service removes guest-OS administration but does not make application security or availability automatic. The app still needs secure identity, data protection, observability, and an appropriate network and resiliency design.
Northwind example
Northwind hosts its ordering API in App Service rather than on a VM. Luis deploys the API and configures its managed identity to retrieve a payment secret from Key Vault. The API runs on an App Service plan, which determines the available capacity and scale behavior. Northwind adds Application Insights to see checkout failures and uses a deployment slot to validate a new version before production.
Common confusion
- App Service is the managed hosting service; an App Service plan is the underlying capacity and billing container.
- VNet integration is mainly an outbound-connectivity feature. A private inbound address normally requires a separate private-endpoint design.
- A successful deployment does not mean the app is safe, correctly configured, or able to survive a dependency failure.
How it fits (diagram)
Where it appears in the route
Compare VMs and App Service through cloud-computing, then read app-service-plan, deployment-slots, app-service-networking, and application-insights.
Related
app-service-plan · deployment-slots · app-service-networking · azure-functions · application-insights · managed-identity · northwind-traders-case-study
📘 Source: Microsoft Learn — App Service overview, checked 2026-09-16.
App Service plans
What it is
An App Service plan supplies the compute capacity and pricing tier for one or more compatible App Service apps. It determines the worker capacity, scale options, and supported features for those apps. Think of it as the shared hosting capacity; the web app is the site running on that capacity.
Why it exists
You need a consistent, predictable compute container that hosts apps and can scale. The plan centralizes size + tier + scale decisions: pick a tier (Free → Premium) for features, and scale up (resize) or out (add instances) at the plan level, which affects every app in it.
Key ideas
- Scale up changes the plan SKU or worker capacity. Scale out changes the number of plan instances. Both decisions can affect every app that shares the plan.
- Plan tiers offer different limits and features, such as scaling, deployment slots, networking, and availability options. SKU names and availability change, so check the current App Service plan documentation for a production choice.
- Sharing a plan can lower cost for small apps, but a busy or faulty app can compete with its neighbors for the same capacity. Put workloads with different performance, scaling, or isolation needs on separate plans.
- An App Service plan is not a VM pool you administer. Azure operates the workers; you select the capacity and app configuration.
Northwind example
Northwind places its ordering API and a small internal admin site on separate plans. A lunch-time surge makes the ordering API scale out; isolating it prevents that surge from consuming the admin site’s capacity. When Northwind tests a new plan SKU, it tests the application behavior and cost, not just whether the portal accepts the setting.
Common confusion
- Scaling a plan can affect all apps on it; scaling a single app may not be an available or equivalent option.
- A plan is not the same as a resource group, subscription, or deployment slot.
- The cheapest tier is not automatically the safest choice when a workload requires a feature or production capacity it does not support.
How it fits (diagram)
Design check
List the apps, expected traffic, isolation need, networking need, slot requirement, availability requirement, and budget before choosing a plan. Confirm each requirement against the current SKU documentation in the target region.
Related
app-service · deployment-slots · app-service-networking · virtual-machine-scale-set · northwind-traders-case-study
📘 Source: Microsoft Learn — App Service plans, checked 2026-09-16.
Deployment slots
What it is
Deployment slots are named live environments for one App Service app, such as production and staging. Each has its own hostname. You can deploy a new version to a non-production slot, test it, then swap it into production so the previously running version becomes the non-production slot.
Why it exists
Shipping directly to the live site is risky. Slots let you deploy to staging, smoke-test with production settings, then swap traffic while App Service prepares the source slot. Swap back to restore the previous version if a regression appears. Long-running work can be abandoned when the former production workers recycle, so applications must tolerate interruption.
Key ideas
- A slot has its own deployment and hostname. Some configuration swaps with the application; deployment slot settings stay with the slot. This distinction is critical for production-only secrets and endpoints.
- A swap warms and redirects the application environments according to App Service’s slot behavior. It can reduce release disruption, but it does not test your application or make a database schema change reversible.
- Swapping back can return the previous application version to production, provided the wider release has not made incompatible changes. Test rollback, health checks, and long-running work before relying on it.
- Slot count and availability depend on the App Service plan tier. Confirm the target plan’s current limits before using slots in a release design.
Northwind example
Northwind deploys a new ordering API version to staging.northwind.... It runs a smoke test that creates a test order without charging a customer. The production payment credential is configured as a slot setting so it stays with production during the swap; staging uses a safe test credential. When the checks pass, Northwind swaps staging into production. If a defect appears, it can swap back—but only after confirming that the deployment did not perform an irreversible data migration.
Common confusion
- A slot is not a separate subscription or full disaster-recovery environment. It shares the parent app’s broader service context.
- A slot swap is not automatically zero risk or zero downtime for every application protocol, connection, background job, and data change.
- Do not put production secrets in a non-sticky setting and assume the swap will keep them in production.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: app-service/deploy-staging-slots
Release checklist
Use representative tests, define which settings are slot-specific, prepare a rollback decision, and coordinate any database or external-service change. Monitor the production app after the swap through Application Insights.
Related
app-service · app-service-plan · application-insights · key-vault · northwind-traders-case-study
📘 Source: Microsoft Learn — Set up staging environments in Azure App Service, checked 2026-09-16. Re-audit when slot availability, swap behavior, or application-restart guidance changes.
Azure Functions
What it is
Azure Functions is an event-driven, serverless compute service. You write small units of code that run when something happens—an HTTP request arrives, a timer fires, a queue receives a message, or a file changes—without operating the underlying servers. The hosting option still determines scaling, networking, capacity, and cost.
Why it exists
Many tasks are event-driven and bursty: an HTTP request, queue message, blob upload, or timer. A consumption-based plan can scale on demand; a dedicated or always-ready plan trades some scale-to-zero behavior for predictable capacity, networking, or reduced startup latency.
Key ideas
- Triggers kick off functions: HTTP trigger, Timer, Azure Storage Queue/Blob/Event Hub triggers, Azure Service Bus, Event Grid, Cosmos DB, and more.
- Bindings: declarative input/output bindings connect to other services (e.g. read from blob, write to queue) with minimal code.
- Hosting options: Flex Consumption is Microsoft’s recommended plan for new serverless apps and provides event-driven scaling, VNet integration, and pay-as-you-go billing. Premium provides always-warm instances and VNet integration; Dedicated runs in an App Service plan; Container Apps can host customized containerized function apps. The older Consumption plan is legacy and Windows-only for new-app decisions.
- Runs inside a Function App — the container grouped with app settings, identity, and runtime config.
- Durable Functions orchestrate stateful, long-running workflows.
- Runs on the Functions runtime; supports .NET, Java, Node, Python, PowerShell.
Northwind example
When a customer order is placed, Northwind writes a message to a queue. A queue-triggered function receives it, checks that the order has not already been processed, then requests shipment. The trigger starts the function; an output binding or SDK call can send the next message. Because messages can be retried, the processing code must be safe to run more than once. Azure runs the function host, but Northwind still owns the code, secrets, authorization, monitoring, and handling of failed work.
How it fits (diagram)
Exam notes
- Serverless ≠ no server: Microsoft manages the servers, but the selected plan determines behavior and costs.
- Choose a plan from requirements such as warm capacity, networking, scaling, and cost; do not assume every Function App has zero idle cost.
- Triggers vs bindings: triggers start the function; bindings connect to input/output data.
- AZ-104: recognize scope — Functions are the serverless compute in the compute spectrum, alongside ACI and AKS. Function Apps often run under an App Service plan (Dedicated) too.
Related
Path MOC · app-service · aci · aks · function-triggers · azure-functions-bindings
Containers
Azure Container Instances (ACI)
What it is
Azure Container Instances (ACI) runs Linux or Windows container images in Azure without requiring you to create or manage virtual machines or a Kubernetes cluster. You define CPU, memory, networking, and a container group; Azure runs that group for you.
Why it exists
Some jobs need one or a small related set of containers quickly: a batch conversion, a short-lived task, or a simple isolated service. ACI is a lightweight runtime choice when full Kubernetes orchestration would add unnecessary operational work.
Key ideas
- A container group is ACI’s scheduling unit. Containers in a group share a host, local network, storage, and lifecycle. This works for a main container plus a closely related sidecar, such as a log helper.
- ACI can run one container or a group. It does not by itself provide Kubernetes-style deployment rollouts, broad service discovery, or general automatic scaling of an application. Use AKS or another appropriate platform when those are requirements.
- ACI can pull images from Azure Container Registry, Docker Hub, and supported registries. A managed identity can authenticate an image pull from ACR without embedding a registry password.
- A group can receive a public IP and FQDN, or run in a virtual-network subnet. A virtual-network deployment requires a NAT gateway for supported outbound connectivity.
- Azure Files can provide persistent storage. Without deliberately mounted storage, container-local state should be treated as temporary.
- Charges depend on the selected configuration and usage. Check current pricing for a production decision rather than using a fixed per-second cost assumption.
How it fits (diagram)
Northwind example
Northwind runs a receipt-conversion job when a batch of PDFs arrives. Luis creates a container group with the converter and a small sidecar that uploads status logs. It mounts an Azure Files share for results and uses a managed identity to pull its image from ACR. ACI starts the group quickly, but Northwind’s scheduler—not ACI alone—decides when to create another job and how to retry a failed batch.
ACI versus AKS and a VM
| Need | Start by considering |
|---|---|
| Run a simple, isolated container or small container group without cluster management | ACI |
| Orchestrate many containerized workloads with Kubernetes features | [[aks |
| Control the operating system and run software that needs a full server | [[azure-vm |
Common confusion
- “Serverless container” means Azure manages the underlying VM infrastructure. It does not mean the application automatically scales, heals, or schedules itself.
- A container image is not a running container group. The group is the deployed runtime instance.
- Giving a group a public IP makes it reachable; it does not make the application secure. Apply identity, network, TLS, and application-security controls.
Related
Path MOC · aks · acr · azure-functions
Sources and re-audit
- Microsoft Learn — What is Azure Container Instances?, checked 2026-09-16.
Azure Kubernetes Service (AKS)
What it is
Azure Kubernetes Service (AKS) is Azure’s managed Kubernetes service for deploying and managing containerized applications. Kubernetes coordinates many containers across compute resources: it schedules pods, replaces failed pods, scales workloads, and exposes services according to the configuration a team supplies.
Why it exists
When a workload needs coordinated services, deployments, scaling, service discovery, and repeated operational patterns, Kubernetes can help. AKS shifts substantial Kubernetes platform work to Azure, but it does not remove the need to design, secure, monitor, and operate the applications running on the cluster.
Key ideas
- AKS creates and manages a control plane. Workloads run in pods on nodes. A node pool groups the compute nodes for a cluster.
- AKS Automatic uses Azure-managed production defaults for nodes, scaling, security, monitoring, and upgrades. AKS Standard gives teams more direct control of cluster configuration and node pools. Choose the mode from actual platform-control needs.
- Kubernetes objects such as Deployments, Services, Ingress, and namespaces describe desired workload state and boundaries. They are configuration the team must understand and maintain.
- AKS integrates with Azure networking, storage, and identity. For example, pods can use persistent volumes backed by Azure Disks or Azure Files, and workloads can pull images from ACR.
- Scaling can involve pod autoscalers and node provisioning or autoscaling. A configured scaler responds to its configured signals; it does not guarantee that every workload can scale safely.
- Pricing, uptime guarantees, and included features vary by AKS mode and pricing tier. Verify the current offering rather than relying on an old blanket “control plane is free” statement.
How it fits (diagram)

Diagrams courtesy of Microsoft Learn / Azure docs: aks/intro-kubernetes
Northwind example
Northwind’s ordering platform has several containerized services: checkout, catalogue, recommendations, and background workers. It uses AKS Automatic to start from Azure’s managed defaults, then defines deployments, health checks, resource limits, identities, and monitoring for each service. When checkout traffic rises, configured Kubernetes scaling can add capacity. Luis still owns application behavior, safe rollout settings, secrets, and the decision of whether a failed dependency should make a pod ready to serve traffic.
AKS versus ACI
| Need | Start by considering |
|---|---|
| Coordinated, multi-service container platform with Kubernetes capabilities | AKS |
| One simple container or small related container group | [[aci |
| Small event-driven code unit without managing containers | [[azure-functions |
Common confusion
- AKS is managed Kubernetes, not “no operations.” Someone still owns workload manifests, release safety, identity, networking, observability, and incident response.
- A healthy Kubernetes node does not prove an application is healthy. Define meaningful readiness, liveness, and monitoring signals.
- Kubernetes authorization and Azure resource authorization are related but distinct. Use the appropriate identity and RBAC model for each boundary.
Related
Path MOC · aci · acr · azure-functions
Sources and re-audit
- Microsoft Learn — What is Azure Kubernetes Service (AKS)?, checked 2026-09-16.
Azure Container Registry (ACR)
What it is
Azure Container Registry (ACR) is a managed registry for container images and related artifacts. A registry stores versioned images so an authorized runtime, such as Container Apps, ACI, AKS, or App Service, can pull the exact software it should run.
Why it exists
An application image must live somewhere between its build and deployment. ACR gives an Azure-controlled location for that handoff, with Azure identity, network, automation, and regional options. It can be appropriate for private workloads, but a public registry is not automatically wrong; choose based on trust, accessibility, and delivery needs.
Key ideas
- A registry contains repositories, which contain tagged images and immutable image snapshots. A tag such as
latestcan move; use an immutable digest when a deployment must prove exactly which bytes it ran. - ACR supports Docker-compatible images and related OCI artifacts, such as Helm charts. It can store Linux and Windows images.
- Basic, Standard, and Premium tiers share core registry features. Premium adds capabilities and larger limits, including geo-replication. Check the current SKU comparison before selecting a tier for private connectivity, replication, or capacity.
- ACR Tasks can build images in Azure on demand or from triggers such as source commits and base-image updates. A build trigger still needs a controlled source, tested output, and a release decision.
- Authenticate with Azure identities, service principals, or the registry’s admin account where permitted. Prefer least-privileged Azure RBAC or repository permissions and avoid embedding a registry password in code or deployment manifests.
- ACR integrates with image-pulling runtimes, but image availability is separate from application authorization and runtime network connectivity.
How it fits (diagram)
Northwind example
Northwind’s build pipeline creates an image for the catalogue service, scans and tests it, then pushes it to northwindregistry.azurecr.io/catalogue. It records the resulting digest. Container Apps pulls that digest through an authorized identity, so the deployment uses the bytes that passed testing. When a new base image needs a security patch, ACR Tasks can rebuild the image, but Northwind still tests and promotes the resulting digest before production uses it.
Registry versus image and runtime
| Term | Main job |
|---|---|
| ACR | Store and distribute images and related artifacts. |
| [[container-image | Container image]] |
| [[azure-app-container-apps | Container Apps]], [[aci |
Common confusion
- A registry does not run code. It stores the image that a separate runtime pulls.
- A successful push does not prove the image is secure or ready for production. Scan, test, and promote intentionally.
- A tag is convenient for people but can change. A digest is safer for traceable deployment and rollback decisions.
Related
Sources and re-audit
- Microsoft Learn — Introduction to Azure Container Registry, checked 2026-09-16.