This chapter covers Azure's container services — Azure Container Instances and Azure Kubernetes Service (AKS) — at the level AZ-900 expects. AZ-900 tests this under objective 2.2, alongside other compute services.
Jump to a section
A simple way to picture Azure Container Instances and AKS
Before standardized shipping containers existed, cargo had to be packed and unpacked differently for every ship, train, and truck — a slow, inconsistent process. Standardized containers changed that: the same container works across ships, trains, and trucks without repacking, because the container itself carries everything it needs inside a consistent format. Software containers work the same way — an application and everything it needs to run (its dependencies, libraries, and configuration) are packaged together in a consistent format that runs the same way regardless of the underlying environment, instead of needing to be reconfigured for each new place it runs.
What containers are
A container packages an application together with everything it needs to run — code, runtime, libraries, and configuration — into a single, consistent unit. This means the application behaves the same way regardless of where the container runs, since its dependencies travel with it rather than depending on what's already installed on the host.
Azure Container Instances (ACI)
Azure Container Instances is a service for running individual containers quickly, without needing to manage the underlying virtual machines or a larger container orchestration platform. It's suited to simple, short-lived, or isolated container workloads.
Azure Kubernetes Service (AKS)
Azure Kubernetes Service is a managed platform for running many containers together at scale, handling tasks like distributing containers across multiple machines, restarting failed containers, and scaling the number of running containers based on demand. Kubernetes itself is an open-source container orchestration technology; AKS is Azure's managed version of it, so Azure handles much of the underlying management overhead.
How containers compare to virtual machines
A virtual machine includes an entire operating system; a container shares the host's operating system kernel and packages only the application and its dependencies, making containers generally lighter-weight and faster to start than a full VM. Containers and VMs solve related but different problems, and are often used together — containers frequently run on top of VMs.
Choosing between ACI and AKS
Azure Container Instances suits simple scenarios — a single container or a small number of them, without needing complex orchestration. Azure Kubernetes Service suits larger, more complex applications made up of many containers that need coordinated management, scaling, and resilience.
Package the application into a container
The application and its dependencies are packaged into a container image, which becomes the consistent, portable unit that gets deployed.
Choose the right hosting service
For a simple, small-scale need, Azure Container Instances offers a quick way to run containers without managing orchestration. For a larger, more complex application with many containers, Azure Kubernetes Service provides that orchestration.
Deploy and run the container
The container image is deployed to the chosen service, which handles running it on the underlying infrastructure.
Scale and manage as needed
For AKS specifically, the orchestration platform can automatically scale the number of running containers and restart failed ones, reducing manual management overhead for complex applications.
A development team building a small utility that processes occasional batch jobs uses Azure Container Instances, since they don't need the complexity of a full orchestration platform for a workload that runs briefly and independently.
A larger e-commerce platform made up of many interconnected microservices uses Azure Kubernetes Service to coordinate dozens of containers together, automatically scaling and restarting them as needed to handle varying traffic and occasional failures — a scale of coordination that would be impractical to manage manually with individual container instances.
Objective 2.2 expects candidates to understand what containers are at a conceptual level, and to distinguish between Azure Container Instances (simple, individual containers) and Azure Kubernetes Service (orchestration for many containers at scale).
A common wrong answer is treating containers and virtual machines as the same thing — containers share the host operating system and are generally lighter-weight, while VMs include a full operating system each. Another common trap is confusing ACI and AKS — ACI is for simple, individual container scenarios; AKS is for orchestrating many containers together at scale.
Stable terms: container, Azure Container Instances (ACI), Azure Kubernetes Service (AKS), Kubernetes. AZ-900 expects conceptual understanding only — implementation-level Kubernetes detail belongs to more advanced, role-based exams.
Memory trick: need to run one or a few simple containers quickly → ACI. Need to coordinate many containers together at scale → AKS.
Containers package an application with its dependencies into a consistent, portable unit that runs the same way across environments.
Containers are generally lighter-weight than virtual machines, since they share the host operating system rather than including a full OS each.
Azure Container Instances is for running individual containers simply, without orchestration.
Azure Kubernetes Service (AKS) is Azure's managed platform for orchestrating many containers together at scale.
These come up on the exam all the time. Here's how to tell them apart.
Azure Container Instances (ACI)
Runs individual containers simply
No orchestration platform to manage
Good fit for simple or short-lived workloads
Faster to get started for a single container
Azure Kubernetes Service (AKS)
Orchestrates many containers together at scale
Handles scaling, restarts, and distribution automatically
Good fit for complex, multi-container applications
More setup, but built for larger, coordinated workloads
Mistake
Containers and virtual machines are the same thing.
Correct
A VM includes a full operating system; a container shares the host's OS kernel and packages only the application and its dependencies, making containers generally lighter-weight and faster to start.
Mistake
Azure Container Instances and Azure Kubernetes Service are interchangeable.
Correct
ACI is meant for running individual containers simply, without orchestration. AKS is a full orchestration platform for managing many containers together at scale — they suit different scenarios.
Mistake
You always need Kubernetes to use containers in Azure.
Correct
For simple scenarios, Azure Container Instances lets you run containers without any orchestration platform at all — Kubernetes/AKS is needed only when coordinating many containers together becomes necessary.
A virtual machine includes a full operating system; a container shares the host's operating system kernel and packages only the application and its dependencies. This generally makes containers lighter-weight and faster to start than a full VM.
Azure Container Instances suits simple scenarios — running one or a small number of containers without needing complex orchestration. Azure Kubernetes Service is better suited to larger applications made up of many containers that need coordinated scaling, restarts, and management.
Kubernetes is an open-source platform for orchestrating containers — automating their deployment, scaling, and management across a group of machines. Azure Kubernetes Service (AKS) is Azure's managed version of Kubernetes, reducing the operational overhead of running it yourself.
You've just covered Azure Container Instances and AKS — now see how well it sticks with free AZ-900 practice questions. Full explanations included, no account needed.
Done with this chapter?