This post is originally posted at medium.com

Azure Container Apps is a fully managed serverless container runtime for building and running cloud-native applications which focuses on the business logic of the apps rather than on cloud infrastructure management.

Azure Container Apps is built upon the foundation consisting of open-source technology with CNCF projects like Kubernetes Event-Driven Autoscaling (KEDA), Distributed Application Runtime (Dapr), and Envoy running on the Azure Kubernetes Service (AKS).

During the past month, I spent quite a time digging deeper and learning more about this serverless offering.

Theoretical learning is great, but nothing beats a practical example! So I've created a simple microservice application (Tasks Management App) which consists of three microservices and each one has certain capabilities to show how Azure Container Apps and Dapr can simplify the building of a microservices application.

Complete practical example on my blog. The source code is available on GitHub.

The below architecture diagram shows the solution components and services I'm using in this practical example

To help understand how I build the application from scratch, I have written various companion blog posts to describe the source code and walk you through the steps.

The application use cases and Azure Container Apps features I will be covered are below:

• An overview of Azure Container Apps Components and Dapr and their core features and capabilities (continue reading…)
• Getting started with Azure Container Apps, build and push container image to Azure Container Registry, then deploy your first Backend API microservice (continue reading…)
• Communication between two microservices (without Dapr) and different options for ingress configurations (continue reading…)
• Introducing Dapr into the application and how it will help simplify complex microservices scenarios such as service discovery, service-to-service invocation, and calling services asynchronously (continue reading…)
• Enable local debugging for multiple microservices applications within VS Code and configure Dapr locally (continue reading…)
• Using Dapr State Management Building Block to store application data into Azure Cosmos DB with simple configurations and without adding CosmosDB SDK to the application (continue reading…)
• Using Dapr Pub/Sub Building Block to enable Async communication between microservices while using Azure Service Bus as a service broker, and see how Dapr will simplify the process on the producer and consumer too (continue reading…)
• Handling external events from different systems and showing the connectivity and interoperability capabilities when introducing Dapr Bindings (continue reading…)
• Introducing Cron binding to trigger application code periodically based on a configurable interval and store processing results Azure Blob Storage using Dapr State Management API (continue reading…)
• Configure Monitoring and Observability for all applications in the Azure Container App Environment and implement distributed tracing between services and resources using Application Insights (continue reading…)
• Use GitHub actions to continuously build, push images to ACR and deploy new Azure Container Apps revisions with code changes (continue reading…)
• Creating the IaC scripts to recreate the entire ACA environment with the supporting resources (Azure Service Bus, Cosmos DB, Azure storage, etc…) using Bicep (continue reading…)
• Configuring Autoscaling for Azure Container Apps using KEDA based on Azure Service Bus Queue length (continue reading…)
• Integrating Health probes in Azure Container Apps (TBA)

I will be adding more posts such as Authentication, services invocation using gRPC, file storage mounting, and using vNETs during the coming period, so stay tuned and thanks for reading.

Happy learning and coding!

References:

Featured Image Credit