Picture this: You’ve just built the first version of your containerized backend application. The code is clean, the architecture is solid, and everything runs on your machine. It’s simple, it’s portable and it meets the requirements. And then comes the question… How do you get that application to your users?
If you’re like most developers, you want to focus on building features, not managing/operating/security/battling infrastructure. You’ve heard about Kubernetes, but honestly, you’d rather not deal with its complexity right now. You just want your container to run reliably in the cloud. Sound familiar?
Enter Azure Container Apps - probably my favourite service across all of the cloud providers. Let me show you why it’s become my go-to solution for deploying containerized applications, and how you can get started with it today. Using everyone’s favourite pizza restaurant - PlantBasedPizza.
What Makes Azure Container Apps Special?
At its core, Azure Container Apps is a serverless platform for running containers. While it’s built on top of Kubernetes, you don’t need to know anything about Kubernetes to use it effectively. Think of it as getting all the benefits of a modern container platform without the operational overhead.
Container Apps is incredibly simple. There are only two concepts at the core of all applications:
- Container Apps Environment - Think of this as your deployment space. It could be your dev, staging, or production environment.
- Container Apps - These are your actual applications, running as containers within the environment.
That’s it. No nodes to manage, no clusters to configure, no complex networking to set up. Just your code, in a container, running in the cloud.
Getting an application running is remarkably straightforward. You only need to specify:
- How much CPU and memory your app needs
- Whether you want public access (ingress)
- Your container image
That’s it. No load balancers to configure, no clusters to manage, no node pools to size. Container Apps handles all of that for you.
And whilst things start simple, you can get more complex if needed. For example, you can define auto-scaling rules. Scale rules can be based on HTTP, TCP, custom data (CPU/memory) and even other Azure services like Azure Service Bus or Azure Event Hubs.
One of my favoutire features is the native integration with Dapr (Distributed Application Runtime). With Dapr enabled, you get:
- Service-to-service invocation using just application names
- Built-in pub/sub capabilities
- State management
- Secrets management
- And so much more, all without changing your application code
For example, if you have two services – order-service and payment-service – they can communicate simply by using each other’s names. No need to manage URLs, service discovery, or retry logic. Honestly, if you’ve not come across Dapr I’d highly recommend checking it out.
Perhaps one of the most underappreciated aspects is that Container Apps provides a nice off-ramp. Since it’s built on Kubernetes, if you ever outgrow its capabilities, you can:
- Migrate to Azure Kubernetes Service (AKS)
- Keep your existing container configurations
- Maintain similar deployment patterns
- Preserve your development workflows
You would still need to actually build the Kubernetes infrastructure, but because under the hood ACA is using open source tooling it’s a relatively safe choice for growing applications – you can start simple and scale up without needing to completely rearchitect your system. And if you do ever need Kubernetes (you probably don’t) you have an off ramp.
Deploying Your First Container App
Let’s get practical. Instead of clicking around in the Azure portal (it’s 2025, after all), we’ll use infrastructure as code. Personally, I’m a big fan of using the same language to define my infrastructure as my application code. Which makes Pulumi an excellent choice for defining and deploying applications to Azure.
Look just how simple it is to define a container app on Azure:
var environment = new ManagedEnvironment("pizza-prod-env", new ManagedEnvironmentArgs
{
ResourceGroupName = resourceGroup.Name,
Location = location,
EnvironmentName = "production",
SkuName = "Consumption"
});
var app = new ContainerApp("pizza-backend", new ContainerAppArgs
{
ResourceGroupName = resourceGroup.Name,
ContainerAppEnvironmentId = environment.Id,
Configuration = new ConfigurationArgs
{
Ingress = new IngressArgs
{
External = true,
TargetPort = 8080, // The port on your local container
Traffic = new TrafficWeightArgs()
{
Weight = 100,
LatestRevision = true
}
}
},
Template = new TemplateArgs
{
Containers =
{
new ContainerArgs
{
Name = "pizza-api",
Image = "your-registry/pizza-api:latest",
Resources = new ContainerResourcesArgs
{
CPU = 0.5,
Memory = "1Gi"
}
}
}
}
});This code creates everything you need to run your application. Let’s break down what’s happening:
- First, we create a Container Apps Environment - this is where your apps will live
- Then, we create the Container App itself, specifying:
- Basic resource requirements (CPU and memory)
- The container image to use
- Whether it should be publicly accessible (external ingress)
Real-World Considerations
Of course, real applications need more than just basic deployment. Azure Container Apps has you covered there too. You can easily:
- Scale based on HTTP traffic or custom metrics
- Set up authentication and authorization
- Use managed identities for secure access to other Azure services
- Deploy multiple containers as sidecars (great for logging agents or service meshes)
For example, adding a DataDog monitoring sidecar is as simple as adding another container to your template:
Containers =
{
// Your main application container
new ContainerArgs { /* ... */ },
// DataDog sidecar
new ContainerArgs
{
Name = "datadog-agent",
Image = "datadog/agent:latest",
Environment =
{
new EnvironmentVarArgs
{
Name = "DD_API_KEY",
SecretRef = "dd-api-key"
}
}
}
}Getting Started
Ready to try it yourself? Here’s what you need:
- A containerized application (if you don’t have one, you can use the example from PlantBasedPizza)
- An Azure subscription
- Pulumi CLI installed (or if Terraform is your jam, then a Terraform example is available in GitHub as well)
The full sample code, including a complete pizza ordering backend, is available in my GitHub repository.
Why Should You Care?
The cloud shouldn’t be complicated. Azure Container Apps gives you a production-ready platform for running containerized applications without the complexity of managing Kubernetes directly. It’s perfect if you want to focus on building features rather than managing infrastructure.
Best of all, if you do eventually need more control or want to migrate to a full Kubernetes cluster (you still probably shouldn’t), you’re already using compatible technologies.
What’s Next?
Start small. Take a simple containerized application and deploy it using the code samples above. Once you’re comfortable with the basics, you can explore more advanced features like:
- Dapr integration for microservices communication
- Auto-scaling rules
- Virtual network integration
Remember, the goal is to keep things simple while maintaining the flexibility to grow as your needs evolve.
Give it a try, and let me know how it goes! Drop a comment below or reach out on socials if you have any questions.